from string import ascii_uppercase
from collections import Counter
from bisect import bisect_left

def partition(P):
    P = [''.join(sorted(p)) for p in P]
    N = len(P)

    for i in range(1, N):
        prev = P[i-1]
        p = P[i]

        if ''.join(sorted(p, reverse=True)) < prev:
            return None

        n = len(p)
        C = Counter(p)
        slen = min(n, len(prev))
        for j in range(slen):
            C[prev[j]] -= 1

        bad = {k for k, v in C.items() if v < 0}

        if not bad and n >= len(prev):
            P[i] = prev + ''.join(sorted(C.elements()))
            continue

        for plen in range(slen-1, -1, -1):
            c = prev[plen]
            C[c] += 1
            if C[c] == 0:
                bad.remove(c)

            if not bad:
                found = ''
                for c in ascii_uppercase:
                    if c > prev[plen] and C[c] > 0:
                        found = c
                        break

                if found != '':
                    C[found] -= 1
                    P[i] = prev[:plen] + found + ''.join(sorted(C.elements()))
                    # print(plen, prev[plen], found)
                    break
        else:
            assert False

    return P

if False:
    import random
    while True:
        N = random.randint(2, 3)
        P = ["".join(random.choices(ascii_uppercase, k=random.randint(1, 8))) for _ in range(N)]

        ans = partition(P)
        if ans is not None:
            assert len(ans) == N
            for a, b in zip(ans, P):
                assert Counter(a) == Counter(b)

            for i in range(1, N):
                assert ans[i-1] <= ans[i], (ans[i-1], ans[i], P)

        print("OK")



def solve():
    N = int(input())
    P = input().split()
    R = partition(P)
    if R is None:
        print("IMPOSSIBLE")
    else:
        print("POSSIBLE")
        print(*R)

for t in range(int(input())):
    print(f"Case #{t+1}:", end=" ")
    solve()