from itertools import combinations
from collections import deque
from math import prod

def normalize(triplet):
    return tuple(sorted(triplet))

def decompose(triplet):
    x, y, z = triplet
    decompositions = []
    for i, val in enumerate((x, y, z)):
        for r in range(1, val // 2 + 1):
            t1 = list((x, y, z))
            t2 = list((x, y, z))
            t1[i] = val - r
            t2[i] = r
            decompositions.append((normalize(tuple(t1)), normalize(tuple(t2))))
    return decompositions

def generate_valid_three_sets(n):
    start = (normalize((n, n, n)),)
    queue = deque([start])
    seen = set()
    valid_sets = []

    while queue:
        current = queue.popleft()
        if len(current) > 3:
            continue
        if len(current) == 3:
            normalized = tuple(sorted(normalize(t) for t in current))
            if len(set(normalized)) == 3:
                if normalized not in seen:
                    seen.add(normalized)
                    valid_sets.append(normalized)
            continue
        for i, t in enumerate(current):
            for d1, d2 in decompose(t):
                new_state = current[:i] + (d1, d2) + current[i+1:]
                queue.append(new_state)
    return valid_sets

def compute_min_T_for_three_triplets(n):
    sets = generate_valid_three_sets(n)
    if not sets:
        return None
    T_values = []
    for triplet_set in sets:
        products = [prod(t) for t in triplet_set]
        T = max(products) - min(products)
        T_values.append(T)
    return min(T_values)

# Example: Generate T values from n = 1 to 50
if __name__ == "__main__":
    for n in range(1, 51):
        min_T = compute_min_T_for_three_triplets(n)
        print(f"n = {n:2d} → min T = {min_T}")