directions = [(1,0),(0,1),(0,-1),(-1,0)]

verbose = False

from copy import deepcopy

def HolySites(grid, initialBoosts, finish):
    triggers = [finish]
    trigger_i = 0
    grid = dict(grid); grid[finish] = "o"
    boosts = {k:list(v) for k,v in initialBoosts.items()}
    while True:
        trigger = triggers[trigger_i]
        if type(trigger) == tuple:
            i,j = trigger # the cell (i,j) became holy! propagate boosts!
            for (ni,nj) in boosts[i,j]:
                if grid[ni,nj] == ".":
                    grid[ni,nj] = "o"
                    triggers.append((ni,nj))
            for (di,dj) in directions:
                if (i,j) in boosts[i+di,j+dj]: continue
                while grid[i+di,j+dj]==".":
                    if (i,j) in boosts[i+di,j+dj]: crash
                    boosts[i+di,j+dj].append((i,j))
                    i,j = i+di,j+dj
                if grid[i+di,j+dj] == "o" and grid[i,j] == ".":
                    grid[i,j] = "o"
                    triggers.append((i,j))

        if verbose:
            height, width = max(grid)
            height, width = height, width+1
            print(i,j)
            for i in range(height):
                print("".join(grid[i,j] for j in range(width)))
            print()

        trigger_i += 1
        if trigger_i == len(triggers):
            return {(i,j) for (i,j) in grid if grid[i,j] == "o"}



def InitialBoosts(grid):
    """ 100 by 100 grid. at most 26 starts and 26 ends. """
    # each [i,j] of grid is # (wall), . (empty), or * (hazard).
    Boosts = {c:[] for c in grid} # dict: (old holy cell) --> [new holy cells]

    height, width = max(grid)
    height, width = height + 1, width + 1

    walls = [(i,j) for (i,j) in grid if grid[i,j] == "#"]
    for (wi,wj) in walls:
        for (di,dj) in directions:
            i,j = wi+di,wj+dj
            if (i,j) not in grid: continue
            while (i+di,j+dj) in grid and grid[i,j] == grid[i+di,j+dj] == ".":
                # we can wallboost from (i,j) to (i+di,j+dj)
                Boosts[i+di,j+dj].append((i,j))
                i,j = i+di,j+dj

    return Boosts

alphabet = "qwertyuiopasdfghjklzxcvbnm"

T = int(input()) # read a line with a single integer
for i in range(1, T + 1):
    R, C = [int(x) for x in input().split(" ")]
    grid = {}
    starts = {}
    finishes = {}
    for i in range(R):
        row = input()
        for j,c in enumerate(row):
            if c in alphabet:
                starts[i,j] = c
                grid[i,j] = "."
            elif c in alphabet.upper():
                finishes[i,j] = c
                grid[i,j] = "."
            else:
                grid[i,j] = c
                
    for (i,j) in [(-1,j) for j in range(C)] +\
            [(R,j) for j in range(C)] +\
            [(i,-1) for i in range(R)] +\
            [(i,C) for i in range(R)]: grid[i,j] = "#"            
    
    B = InitialBoosts(grid)
    outputs = []
    for f in finishes:
        holycells = HolySites(grid, B, f)
        for s in starts:
            if s in holycells:
                outputs.append(starts[s]+finishes[f])
    output = " ".join(sorted(outputs)) if outputs else "NONE"
    print(f'Case #{i}: {output}')