import fileinput

PRIJEVODNA_JEDINICA = '<prijevodna_jedinica>'
VANJSKA_DEKLARACIJA = '<vanjska_deklaracija>'
DEFINICIJA_FUNKCIJE = '<definicija_funkcije>'
DEKLARACIJA = '<deklaracija>'
IME_TIPA = '<ime_tipa>'
LISTA_INIT_DEKLARATORA = '<lista_init_deklaratora>'
LISTA_PARAMETARA = '<lista_parametara>'
SLOZENA_NAREDBA = '<slozena_naredba>'
DEKLARACIJA_PARAMETRA = '<deklaracija_parametra>'
SPECIFIKATOR_TIPA = '<specifikator_tipa>'
LISTA_NAREDBI = '<lista_naredbi>'
LISTA_DEKLARACIJA = '<lista_deklaracija>'
NAREDBA = '<naredba>'
IZRAZ_NAREDBA = '<izraz_naredba>'
NAREDBA_SKOKA = '<naredba_skoka>'
NAREDBA_GRANANJA = '<naredba_grananja>'
NAREDBA_PETLJE = '<naredba_petlje>'
IZRAZ = '<izraz>'
IZRAZ_PRIDRUZIVANJA = '<izraz_pridruzivanja>'
POSTFIKS_IZRAZ = '<postfiks_izraz>'
LOG_ILI_IZRAZ = '<log_ili_izraz>'
LOG_I_IZRAZ = '<log_i_izraz>'
BIN_ILI_IZRAZ = '<bin_ili_izraz>'
BIN_XILI_IZRAZ = '<bin_xili_izraz>'
BIN_I_IZRAZ = '<bin_i_izraz>'
JEDNAKOSNI_IZRAZ = '<jednakosni_izraz>'
ODNOSNI_IZRAZ = '<odnosni_izraz>'
ADITIVNI_IZRAZ = '<aditivni_izraz>'
MULTIPLIKATIVNI_IZRAZ = '<multiplikativni_izraz>'
CAST_IZRAZ = '<cast_izraz>'
UNARNI_IZRAZ = '<unarni_izraz>'
UNARNI_OPERATOR = '<unarni_operator>'
PRIMARNI_IZRAZ = '<primarni_izraz>'
LISTA_ARGUMENATA = '<lista_argumenata>'

class Node:
    def __init__(self):
        self.parent = None
        self.children = []
        self.value = None
        self.depth = None
        pass
    def __str__(self):
        return self.value

def solveListaDeklaracija(node):
    if node.children[0].value == DEKLARACIJA:
        solveDeklaracija(node.children[0])
    else:
        solveListaDeklaracija(node.children[0])
        solveDeklaracija(node.children[1])

def solveSpecifikatorTipa(node):
    print("TODO: " + SPECIFIKATOR_TIPA + ", ovdje NEMA daljeg širenja!")

def solveUnarniOperator(node):
    print("TODO: " + UNARNI_OPERATOR)

def solveUnarniIzraz(node):
    if node.children[0].value == POSTFIKS_IZRAZ:
        solvePostfiksIzraz(node.children[0])
    elif node.children[1].value == UNARNI_IZRAZ:
        solveUnarniIzraz(node.children[1])
    else:
        solveUnarniOperator(node.children[0])
        solveCastIzraz(node.children[1])

def solveCastIzraz(node):
    if node.children[0].value == UNARNI_IZRAZ:
        solveUnarniIzraz(node.children[0])
    else:
        solveImeTipa(node.children[1])
        solveCastIzraz(node.children[3])

def solveMultiplikativniIzraz(node):
    if node.children[0].value == MULTIPLIKATIVNI_IZRAZ:
        solveMultiplikativniIzraz(node.children[0])
        solveCastIzraz(node.children[2])
    else:
        solveCastIzraz(node.children[0])

def solveAditivniIzraz(node):
    if node.children[0].value == ADITIVNI_IZRAZ:
        solveAditivniIzraz(node.children[0])
        solveMultiplikativniIzraz(node.children[2])
    else:
        solveMultiplikativniIzraz(node.children[0])

def solveOdnosniIzraz(node):
    if node.children[0].value == ODNOSNI_IZRAZ:
        solveOdnosniIzraz(node.children[0])
        solveAditivniIzraz(node.children[2])
    else:
        solveAditivniIzraz(node.children[0])

def solveJednakosniIzraz(node):
    if node.children[0].value == JEDNAKOSNI_IZRAZ:
        solveJednakosniIzraz(node.children[0])
        solveOdnosniIzraz(node.children[2])
    else:
        solveOdnosniIzraz(node.children[0])

def solveBinIIzraz(node):
    if node.children[0].value == BIN_I_IZRAZ:
        solveBinIIzraz(node.children[0])
        solveJednakosniIzraz(node.children[2])
    else:
        solveJednakosniIzraz(node.children[0])

def solveBinXiliIzraz(node):
    if node.children[0].value == BIN_I_IZRAZ:
        solveBinIIzraz(node.children[0])
    else:
        solveBinXiliIzraz(node.children[0])
        solveBinIIzraz(node.children[2])

def solveBinIliIzraz(node):
    if node.children[0].value == BIN_XILI_IZRAZ:
        solveBinXiliIzraz(node.children[0])
    else:
        solveBinIliIzraz(node.children[0])
        solveBinXiliIzraz(node.children[2])

def solveLogIIzraz(node):
    if node.children[0].value == LOG_I_IZRAZ:
        solveLogIIzraz(node.children[0])
        solveBinIliIzraz(node.children[2])
    else:
        solveBinIliIzraz(node.children[0])

def solveLogIliIzraz(node):
    if node.children[0].value == LOG_ILI_IZRAZ:
        solveLogIliIzraz(node.children[0])
        solveLogIIzraz(node.children[2])
    else:
        solveLogIIzraz(node.children[0])

def solvePrimarniIzraz(node):
    if len(node.children) == 3:
        solveIzraz(node.children[1])

def solveListaArgumenata(node):
    if node.children[0].value == LISTA_ARGUMENATA:
        solveListaArgumenata(node.children[0])
        solveIzrazPridruzivanja(node.children[2])
    else:
        solveIzrazPridruzivanja(node.children[0])

def solvePostfiksIzraz(node):
    if node.children[0].value == PRIMARNI_IZRAZ:
        solvePrimarniIzraz(node.children[0])
    else:
        solvePostfiksIzraz(node.children[0])
        if len(node.children) > 2:
            if node.children[2].value == IZRAZ:
                solveIzraz(node.children[2])
            elif node.children[2].value == LISTA_ARGUMENATA:
                solveListaArgumenata(node.children[2])

def solveIzrazPridruzivanja(node):
    if node.children[0].value == LOG_ILI_IZRAZ:
        solveLogIliIzraz(node.children[0])
    else:
        solvePostfiksIzraz(node.children[0])
        solveIzrazPridruzivanja(node.children[2])

def solveIzraz(node):
    if node.children[0].value == IZRAZ_PRIDRUZIVANJA:
        solveIzrazPridruzivanja(node.children[0])
    else:
        solveIzraz(node.children[0])
        solveIzrazPridruzivanja(node.children[2])

def solveIzrazNaredba(node):
    if node.children[0].value == IZRAZ:
        solveIzraz(node.children[0])

def solveNaredbaGrananja(node):
    print("TODO: " + NAREDBA_GRANANJA)

def solveNaredbaPetlje(node):
    print("TODO: " + NAREDBA_PETLJE)

def solveNaredbaSkoka(node):
    if node.children[1].value == IZRAZ:
        solveIzraz(node.children[1])

def solveNaredba(node):
    if node.children[0].value == SLOZENA_NAREDBA:
        solveSlozenaNaredba(node.children[0])
    elif node.children[0].value == IZRAZ_NAREDBA:
        solveIzrazNaredba(node.children[0])
    elif node.children[0].value == NAREDBA_GRANANJA:
        solveNaredbaGrananja(node.children[0])
    elif node.children[0].value == NAREDBA_PETLJE:
        solveNaredbaPetlje(node.children[0])
    else:
        solveNaredbaSkoka(node.children[0])

def solveListaNaredbi(node):
    if node.children[0].value == NAREDBA:
        solveNaredba(node.children[0])
    else:
        solveListaNaredbi(node.children[0])
        solveNaredba(node.children[1])

def solveImeTipa(node):
    if node.children[0].value == SPECIFIKATOR_TIPA:
        solveSpecifikatorTipa(node.children[0])
    else:
        solveSpecifikatorTipa(node.children[1])

def solveListaInitDeklaratora(node):
    print("TODO: " + LISTA_INIT_DEKLARATORA)

def solveSlozenaNaredba(node):
    if node.children[1].value == LISTA_NAREDBI:
        solveListaNaredbi(node.children[1])
    else:
        solveListaDeklaracija(node.children[1])
        solveListaNaredbi(node.children[2])

def solveDeklaracijaParametra(node):
    solveImeTipa(node.children[0])

def solveListaParametara(node):
    if node.children[0].value == DEKLARACIJA_PARAMETRA:
        solveDeklaracijaParametra(node.children[0])
    else:
        solveListaParametara(node.children[0])
        solveDeklaracijaParametra(node.children[2])

def solveDeklaracija(node):
    solveImeTipa(node.children[0])
    solveListaInitDeklaratora(node.children[1])

def solveDefinicijaFunkcije(node):
    if node.children[3].value == LISTA_PARAMETARA:
        solveImeTipa(node.children[0])
        solveListaParametara(node.children[3])
        solveSlozenaNaredba(node.children[5])
    else:
        solveImeTipa(node.children[0])
        solveSlozenaNaredba(node.children[5])


def solveVanjskaDeklaracija(node):
    if node.children[0].value == DEFINICIJA_FUNKCIJE:
        solveDefinicijaFunkcije(node.children[0])
    else:
        solveDeklaracija(node.children[0])

def solvePrijevodnaJedinica(node):
    if node.children[0].value == VANJSKA_DEKLARACIJA:
        solveVanjskaDeklaracija(node.children[0])
    else:
        solvePrijevodnaJedinica(node.children[0])
        solveVanjskaDeklaracija(node.children[1])

def solve(node):
    if node.value == PRIJEVODNA_JEDINICA:
        solvePrijevodnaJedinica(node)
    print("Gotovo")

def main():
    #UCITAVANJE STABLA
    lastNode = None
    root = Node()

    for line in fileinput.input("input/2.in"):
        depth = len(line) - len(line.lstrip(' '))
        val = line.strip()
        if lastNode is None:
            root.value = val
            root.depth = 0
            lastNode = root
        else:
            while lastNode.depth >= depth:
                lastNode = lastNode.parent
            currNode = Node()
            currNode.value = val
            currNode.depth = depth
            currNode.parent = lastNode
            lastNode.children.append(currNode)
            lastNode = currNode

    #RJESAVANJE
    solve(root)

if __name__ == "__main__":
    main()