import sys
from collections import deque

def get_neighbours(r, c):
    return [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]

def bfs(grid, start, finish):
    R, C = len(grid), len(grid[0])
    visited = {(r, c): False for r in range(R) for c in range(C)}
    visited[start] = True
    queue = deque([start])
    probs = {start: 1.0}
    while queue:
        curr = queue.popleft()
        if curr == finish:
            return probs[curr] >= 1 - 1e-100
        r, c = curr
        if grid[r][c] == '*':
            continue
        neighbours = get_neighbours(r, c)
        count_walls = count_hazards = 0
        for r_new, c_new in neighbours:
            if r_new < 0 or r_new >= R or c_new < 0 or c_new >= C:
                continue
            if grid[r_new][c_new] == '#':
                count_walls += 1
            elif grid[r_new][c_new] == '*':
                count_hazards += 1
            else:
                if (r_new, c_new) == finish:
                    probs[(r_new, c_new)] = probs[curr]
                elif not visited[(r_new, c_new)]:
                    visited[(r_new, c_new)] = True
                    queue.append((r_new, c_new))
                    probs[(r_new, c_new)] = 0.5 * probs[curr]
        if count_walls + count_hazards == 4:
            continue
        # adjust probability for misheard commands
        if count_walls + count_hazards == 3:
            if count_hazards == 1:
                probs[curr] *= 0.5
            else:
                probs[curr] *= 0.25
        else:
            probs[curr] *= 0.25
    return False

def solve_case(case_num, grid):
    starts, finishes = [], []
    R, C = len(grid), len(grid[0])
    for r in range(R):
        for c in range(C):
            if grid[r][c].islower():
                starts.append((r, c))
            elif grid[r][c].isupper():
                finishes.append((r, c))
    drivable_pairs = []
    for start in starts:
        for finish in finishes:
            if bfs(grid, start, finish):
                drivable_pairs.append((start, finish))
    if not drivable_pairs:
        print(f"Case #{case_num}: NONE")
    else:
        drivable_pairs = sorted(drivable_pairs, key=lambda x: x[0][0]*C+x[0][1])
        output_str = " ".join([f"{chr(grid[pair[0][0]][pair[0][1]]).upper()}{chr(grid[pair[1][0]][pair[1][1]])}" for pair in drivable_pairs])
        print(f"Case #{case_num}: {output_str}")

# read input
input_lines = [line.strip() for line in sys.stdin.readlines()]
num_cases = int(input_lines[0])
line_idx = 1
for case_num in range(1, num_cases+1):
    R, C = map(int, input_lines[line_idx].split())
    grid = [[char for char in line] for line in input_lines[line_idx+1:line_idx+1+R