**Looking for feedback/validation!!!**

I wrote an exhaustive search script with the following python code:

```python
def solve(data, n=6):
    # Who's turn? A=0,B=1,C=2
    i = (n - 1) % len(data)
    return {
        x
        for x in {
            # the new hat configuration, subbing in
            # this round's candidates into the existing
            # hat configuration.
            (*data[:i], x, *data[i + 1 :])
            for x in {
                # try all a+b, a-b, b-a combos
                a + x * b
                for aa, a in enumerate(data)
                # ignore candidate
                if aa != i
                for bb, b in enumerate(data)
                # ignore candidate
                if bb != i 
                # don't duplicate
                and bb != aa
                # add and subtract
                for x in (-1, 1)
            }
            # must be valid hat number
            if x > 0
        }
        # recursion termination condition
        if n == 1 
        or
        # All previous rounds must not have produced a single candidate
        all(len(solve(x, n - j)) == 2 for j in range(1, n))
    }


v = 144
for i in range(10000):
    for data in ((i, v - i, v), (i, v + i, v), (i, i - v, v)):
        s = solve(data)
        if all(x >= 1 for x in data) and len(s) == 1 and next(iter(s))[-1] == v:
            print(data)
```

It returns the following answer:
```
32  112
36  108
54  90
64  80
108 36
```

# How it works

Exhaustive search of candidate (a,b,c) pairs are passed to a validator `solve` function, which returns all potential valid hats assuming `n` rounds have elapsed, and all previous rounds have produced `I don't know` answers.

Then we simply select candidates which returned only a single candidate.