Cd ok?

#include <bits/stdc++.h>
#include <iostream>

#define endl '\n';

using namespace std;


struct bst{
    bst* left;
    bst* right;
    string value;
    bool diretorio;
    bst* arquivos;

};

struct bst_min{
    bst* root;
    string value;
};

void visit(bst* root){
    cout << root -> value << endl;
}

bst* bst_search(bst* root, string v){
    if(root == NULL){
        return NULL;
    } else if (v == root -> value){
        return root;
    } else if (v < root -> value){
        return bst_search(root -> left, v);
    } else{
        return bst_search(root -> right, v);
    }
}

bst* bst_insert_directory(bst* root, string v){
    if(root == NULL){
        bst* n = new bst;
        // bst* subfiles = new bst;
        n -> value = v;
        n -> left = NULL;
        n -> right = NULL;
        n -> diretorio = true;
        // subfiles -> value = v;
        // subfiles -> left = NULL;
        // subfiles -> right = NULL;
        // subfiles -> diretorio = true;
        // n -> arquivos = subfiles;
        n -> arquivos = NULL;
        return n;
    } else if(v == root -> value){
        return NULL;
    } else if(v < root -> value){
        root -> left = bst_insert_directory(root -> left, v);
        return root;
    } else {
        root -> right = bst_insert_directory(root -> right, v);
        return root;
    }
}

bst* bst_insert_file(bst* root, string v){
    if(root == NULL){
        bst* n = new bst;
        n -> value = v;
        n -> left = NULL;
        n -> right = NULL;
        n -> diretorio = false;
        n -> arquivos = NULL;
        return n;
    } else if(v == root -> value){
        return NULL;
    } else if(v < root -> value){
        root -> left = bst_insert_file(root -> left, v);
        return root;
    } else {
        root -> right = bst_insert_file(root -> right, v);
        return root;
    }
}

bst_min* bst_delete_min(bst* root){
    if(root -> left == NULL){
        string m = root -> value;
        bst* r = root -> right;
        delete root;
        bst_min* rm = new bst_min;
        rm -> value = m;
        rm -> root = r;
        return rm;
    } else {
        bst_min* rm = bst_delete_min(root -> left);
        root -> left = rm -> root;
        rm -> root = root;
        return rm;
    }
}

bst* bst_delete(bst* root, string v){
    if(root == NULL){
        return NULL;
    } else if(v < root -> value){
        root -> left = bst_delete(root -> left, v);
        return root;
    } else if( v > root -> value){
        root -> right = bst_delete(root -> right, v);
        return root;
    } else{
        if(root -> left == NULL){
            bst* r = root -> right;
            delete root;
            return r;
        } else if(root -> right == NULL){
            bst* l = root -> left;
            delete root;
            return l;
        } else {
            bst_min* rm = bst_delete_min(root -> right);
            root -> right = rm -> root;
            root -> value = rm -> value;
            return root;
        }
    }
}

void preorder(bst* root){
    if(root == NULL){
        return;
    }
    visit(root);
    preorder(root -> left);
    preorder(root -> right);
}

void inorder(bst* root){
    if(root == NULL){
        return;
    }
    inorder(root -> left);
    visit(root);
    inorder(root -> right);
}

void posorder(bst* root){
    if(root == NULL){
        return;
    }
    posorder(root -> left);
    posorder(root -> right);
    visit(root);
}

struct my_list{
    bst* root;
    my_list* next;
};

my_list* my_list_insert(my_list* cur, bst* y){
    my_list* n = new my_list;
    n -> root = y;
    n -> next = cur -> next;
    cur -> next = n;
    return cur;
}

my_list* my_list_delete(my_list* cur){
    my_list* p = cur -> next;
    cur -> next = p -> next;
    delete p;
    return cur;
}

void tree_preorder(bst* root, int iteracao){
    for(int i = 0; i < iteracao; i++){
        cout << "    ";
    }

    if(root == NULL){
        return;
    }
    visit(root);
    if(root -> diretorio){
        tree_preorder(root -> arquivos, iteracao++);
    }
    tree_preorder(root -> left, iteracao);
    tree_preorder(root -> right, iteracao);
}

void tree_inorder(bst* root, int iteracao){
    for(int i = 0; i < iteracao; i++){
        cout << "    ";
    }

    if(root == NULL){
        return;
    }

    tree_inorder(root -> left, iteracao);
    visit(root);
    if(root -> diretorio){
        tree_inorder(root -> arquivos, iteracao++);
    }
    tree_inorder(root -> right, iteracao);
}

void tree_posorder(bst* root, int iteracao){
    for(int i = 0; i < iteracao; i++){
        cout << "    ";
    }

    if(root == NULL){
        return;
    }
    tree_posorder(root -> left, iteracao);
    tree_posorder(root -> right, iteracao);
    visit(root);
    if(root -> diretorio){
        tree_posorder(root -> arquivos, iteracao++);
    }
}

struct my_stack{
    my_list* top;

    my_stack(){
        top = new my_list;
    }
};

my_stack* my_stack_push(my_stack* pilha, bst* v){
    pilha -> top = my_list_insert(pilha -> top, v);

    return pilha;
}

my_stack* my_stack_pop(my_stack* pilha){
    pilha -> top = my_list_delete(pilha -> top);
    return pilha;
}

//int main(){
    // my_stack* pilha = new my_stack;
    // bst* a = new bst;
    // a = bst_insert_file(a, "adsd");
    // pilha = my_stack_push(pilha, a);

    // cout << a -> value;


    // bst* root = NULL;

    // root = bst_insert_directory(root, "e");
    // root = bst_insert_directory(root, "f");
    // root = bst_insert_directory(root, "a");
    // root = bst_insert_file(root, "d");
    // root = bst_insert_file(root, "b");
    // root = bst_insert_directory(root, "c");

    // cout << root -> value << endl;

    // my_stack* pilha = new my_stack;
    // pilha = my_stack_push(pilha, root);

    // bst* root2 = bst_delete(root, "e");

    // cout << pilha -> top -> next -> root -> value << endl;

    // my_list* ad = new my_list;
    // ad = my_list_insert(ad, root);

    // bst* root2 = NULL;
    // root2 = bst_insert_directory(root2, "asdf");
    // ad = my_list_insert(ad, root2);

    // //cout << ad -> next -> root -> value;

    // ad = my_list_delete(ad);
    // //cout << ad -> next -> root -> value;

    // root = bst_delete(root, "a");
    // string print;
    // if(bst_search(root, "a") == NULL){
    //  print = "nulo";
    // } else
    // //cout << print << endl;

    //preorder(root);
    //return 0;
//}


int main(){
    //my_list* pilha = new my_list;
    bst** buffer = new bst*[100];
    int index = 0;
    bst* diretorio = NULL;
    bst* diretoriogeral = NULL;
    diretoriogeral = bst_insert_directory(diretorio, "/");
    diretorio = bst_insert_directory(diretorio, "/") -> arquivos;
    buffer[index] = diretoriogeral;
    // cout << diretoriogeral -> value << endl;
    // cout << buffer[index] -> value << endl;

    index++;
    //pilha = my_list_insert(pilha, diretorio);
    //my_stack* pilha = new my_stack;
    //pilha = my_stack_push(pilha, diretoriogeral);

    //cout << pilha -> top -> next-> root -> value << endl;
    string command;
    while(cin >> command){
        //cout << "lixo" << endl;
        if(command == "cd"){
            string directory;
            cin >> directory;
            if(directory == ".."){
                if(buffer[index - 1] -> value =="/"){} else {
                    diretorio = buffer[index - 2] -> arquivos;
                    index--;
                }

                //if(diretorio -> value == "/"){} else {

                    //diretorio = pilha -> top -> next-> root;
                    //pilha = my_stack_pop(pilha);
                //}


            } else {
                bst* tochange = bst_search(diretorio,directory);
                //cout << tochange -> value << endl;

                if(tochange == NULL){
                    cout << "No such file or directory" << endl;
                } else {
                    if(tochange -> diretorio){
                        //pilha = my_stack_push(pilha, diretorio);
                        //cout << pilha -> top -> next-> root -> value << endl;
                        //cout << "aqui" << endl;
                        buffer[index - 1] -> arquivos = diretorio;
                        buffer[index] = tochange;
                        index++;
                        diretorio = tochange -> arquivos;
                    } else {
                        cout << "Not a directory" << endl;
                    }
                }
            }
        } else if(command == "ls"){
            inorder(diretorio);
        } else if(command == "touch"){
            string file;
            cin >> file;

            bst* toinclude = bst_insert_file(diretorio,file);
            if(toinclude == NULL){
                cout << "File exists" << endl;
            } else {
                diretorio = toinclude;
            }
        } else if(command == "mkdir"){
            string file;
            cin >> file;

            bst* toinclude = bst_insert_directory(diretorio,file);
            if(toinclude == NULL){
                cout << "File exists" << endl;
            } else {
                diretorio = toinclude;
            }
        } else if(command == "pwd"){
            cout << buffer[index - 1] -> value  << endl;
        } else if(command == "tree"){
            string arg;
            cin >> arg;
            if(arg == "--pre-order"){
                tree_preorder(diretorio, 0);
            } else if(arg == "--in-order"){
                tree_inorder(diretorio, 0);
            } else if(arg == "--post-order"){
                tree_posorder(diretorio,0);
            } else {
                cout << "Illegal option" << endl;
            }
        } else if(command == "rm"){
            string deletar;
            cin >> deletar;
            bst* todelete = bst_delete(diretorio, deletar);
            if(todelete == NULL){
                cout << "No such file or directory" << endl;
            } else {
                diretorio = todelete;
            }
        } else {
            cout << "Command not found" << endl;
        }
    }

    return 0;
}