# dziala
def delta(formula, stale):
    if 'a' not in stale:
        stale.append('a')
        stala = 'a'
    elif 'b' not in stale:
        stale.append('b')
        stala = 'b'
    elif 'c' not in stale:
        stale.append('c')
        stala = 'c'
    elif 'd' not in stale:
        stale.append('d')
        stala = 'd'
    elif 'e' not in stale:
        stale.append('e')
        stala = 'e'
    zmienna = formula[-1]
    del formula[-1]
    del formula[0]
    for indeksele in range(len(formula)):
        formula[indeksele] = list(formula[indeksele])
        for indeks in range(len(formula[indeksele])):
            if formula[indeksele][indeks] == zmienna:
                formula[indeksele][indeks] = stala
        formula[indeksele] = "".join(formula[indeksele])
    return formula


def alfa(formula):
    print(formula)
    if formula[0] in ['NOT', '~', '¬']:
        del formula[0]
    operator = formula[0]
    del formula[0]
    print(formula)
    onp = list(reversed(formula))
    a1, a2 = [], []
    print("Operator:", operator)
    print("ONP:", onp)
    for element in onp:
        if not a1:
            a1.append(element)
        elif element in ['NOT', '~', '¬']:
            if not a2:
                a1.append('NOT')
            else:
                a2.append('NOT')
        elif element in ['AND', '&', '∧', 'OR', '|', '∨', 'IMPLIES', '→', 'IFF', '↔', 'XOR', '⊕']:
            a1 = a1 + a2
            a1.append(element)
            a2 = []
        elif not a2:
            a2.append(element)
    print("A1:", a1, "A2:", a2)
    if operator in ['NOT', '~', '¬']:
        return list(reversed(a1))
    # if formula[0] in ['NOT', '~', '¬'] and formula[1] in ['NOT', '~', '¬']:
    #     return [formula[2:]]
    elif operator in ['AND', '&', '∧']:
        return [[list(reversed(a1)), list(reversed(a2))]]
    # elif formula[0] in ['AND', '&', '∧']:
    #     return [[[formula[1]], [formula[2]]]]
    elif operator in ['OR', '|', '∨']:
        return [[list(reversed(['NOT']+a1)), list(reversed(['NOT']+a2))]]
    # elif formula[0] in ['NOT', '~', '¬'] and formula[1] in ['OR', '|', '∨']:
    #     return [[['NOT', formula[2]], ['NOT', formula[3]]]]
    elif operator in ['IMPLIES', '→']:
        return [[list(reversed(a1)), list(reversed(['NOT']+a2))]]
    # elif formula[0] in ['NOT', '~', '¬'] and formula[1] in ['IMPLIES', '→']:
    #     return [[[formula[2]], ['NOT', formula[3]]]]
    elif operator in ['IFF', '↔', 'XOR', '⊕']:
        return [[list(reversed(a1 + a2 + ['IMPLIES'])), list(reversed(a2 + a1 + ['IMPLIES']))]]
    # elif formula[0] in ['IFF', '↔']:
    #     return [[['IMPLIES', formula[1], formula[2]], ['IMPLIES', formula[2], formula[1]]]]
    # elif formula[0] in ['NOT', '~', '¬'] and formula[1] in ['XOR', '⊕']:
    #     return [[['IMPLIES', formula[2], formula[3]], ['IMPLIES', formula[3], formula[2]]]]

def beta(formula):
    #moze byc zle, nie bylo wcale testowane
    if formula[0] in ['NOT', '~', '¬'] and formula[1] in['AND', '&', '∧']:
        return [['NOT', formula[3]], ['NOT', formula[2]]]
    elif formula[0] in ['OR', '|', '∨']:
        return [[formula[2]], [formula[1]]]
    elif formula[0] in ['IMPLIES', '→']:
        return [['NOT', formula[2]], [formula[1]]]
    elif formula[0] in ['NOT', '~', '¬'] and formula[1] in ['IFF', '↔']:
        return [['NOT', 'IMPLIES', formula[3], formula[2]], ['NOT', 'IMPLIES', formula[2], formula[3]]]
    elif formula[0] in ['XOR', '⊕']:
        return [['NOT', 'IMPLIES', formula[1], formula[2]], ['NOT', 'IMPLIES', formula[2], formula[1]]]



stale = []
pierwotna_formula = input().split()
stack = []
for wyrazenie in pierwotna_formula:
    if wyrazenie in 'abcdeABCDEFGHIJKLMNOPQRSTUVWXYZ':
        stack.append(wyrazenie)
        if wyrazenie in 'abcde':
            if wyrazenie not in stale:
                stale.append(wyrazenie)
    if wyrazenie[0] in 'fghijklmnpqrstuvwxyz':
        arguments = []
        for i in range(0, int(wyrazenie[2:])):
            arguments.append(stack.pop())
        joined_args = ', '.join(reversed(arguments))
        stack.append(wyrazenie[0] + ' ' + '(' + ' ' + joined_args + ' ' + ')')
    elif wyrazenie in ['NOT', '~', '¬', 'AND', '&', '∧', 'OR', '|', '∨', 'IMPLIES', '→', 'IFF', '↔', 'XOR', '⊕', 'FORALL', '∀', 'EXISTS', '∃']:
        stack.append(wyrazenie)
pierwotna_formula = stack
pierwotna_formula.reverse()
print(pierwotna_formula)
print(stale)
bylo_not = False
for element in pierwotna_formula:
    if element in ['NOT', '~', '¬']:
        if bylo_not:
            print("alfa")
            print(alfa(pierwotna_formula))
            bylo_not = False
        else:
            bylo_not = True
    elif element in ['AND', '&', '∧', 'OR', '|', '∨', 'IMPLIES', '→', 'IFF', '↔', 'XOR', '⊕', 'FORALL', '∀', 'EXISTS', '∃']:
        if element in ['AND', '&', '∧']:
            if bylo_not:
                print("BETA")
                print(beta(pierwotna_formula))
                bylo_not = False
            else:
                print("ALFA")
                print(alfa(pierwotna_formula))
        elif element in ['OR', '|', '∨']:
            if bylo_not:
                print("ALFA")
                print(alfa(pierwotna_formula))
                bylo_not = False
            else:
                print("BETA")
                print(beta(pierwotna_formula))
        elif element in ['IMPLIES', '→']:
            if bylo_not:
                print("ALFA")
                print(alfa(pierwotna_formula))
                bylo_not = False
            else:
                print("BETA")
                print(beta(pierwotna_formula))
        elif element in ['IMPLIES', '→']:
            if bylo_not:
                print("ALFA")
                print(alfa(pierwotna_formula))
                bylo_not = False
            else:
                print("BETA")
                print(beta(pierwotna_formula))
        elif element in ['IFF', '↔']:
            if bylo_not:
                print("BETA")
                print(beta(pierwotna_formula))
                bylo_not = False
            else:
                print("ALFA")
                print(alfa(pierwotna_formula))
        elif element in ['XOR', '⊕']:
            if bylo_not:
                print("ALFA")
                print(alfa(pierwotna_formula))
                bylo_not = False
            else:
                print("BETA")
                print(beta(pierwotna_formula))
        elif element in ['FORALL', '∀']:
            if bylo_not:
                print("DELTA")
                bylo_not = False
            else:
                print("GAMMA")
        elif element in ['EXISTS', '∃']:
            if bylo_not:
                print("GAMMA")
                bylo_not = False
            else:
                print("DELTA")
                print(pierwotna_formula, stale)
                delta(pierwotna_formula, stale)
                print(pierwotna_formula, stale)