import itertools

def test(expression, n):
    """Given an expression, returns a tuple of all possible results"""

    results = []

    for input_ in itertools.product([0, 1], repeat=n):
        for i in range(n):
            locals()[chr(ord("A")+i)] = input_[i]
            
        results.append(int(eval(expression)))

    return tuple(results)

def solve(n):
    assert n <= 26
    
    solution_dict = {}

    for expression in ["0", "1"] + [chr(ord("A")+x) for x in range(n)]:
        solution_dict[test(expression, n)] = expression

    while len(solution_dict) < 2**(2**n):
        update_dict = {}
        
        for key1 in solution_dict:
            expression1 = solution_dict[key1]
            
            if len(expression1) > 1:
                expression1 = "({})".format(expression1)
                
            for key2 in solution_dict:
                expression2 = solution_dict[key2]
                
                if len(expression2) > 1:
                    expression2 = "({})".format(expression2)

                new_expression = "{}<{}".format(expression1, expression2)
                results = test(new_expression, n)

                if results not in solution_dict:
                    update_dict[results] = new_expression

                elif len(new_expression) < len(solution_dict[results]):
                    update_dict[results] = new_expression

        solution_dict.update(update_dict)

    for result in sorted(solution_dict):
        print(solution_dict[result])

solve(n=2)