def canbereached(R,C,cell,left,right,up,down,grid):
    res=set([cell])
    tmp={}
    while len(tmp)<len(res):
        tmp=res.copy()
        for (y,x) in tmp:
            j,i=left[(y,x)]
            if grid[j][i]=='#':
                for xx in range(i+1,x):
                    res.add((y,xx))
            jj,ii=right[(y,x)]
            if grid[jj][ii]=='#':
                for xx in range(x+1,ii):
                    res.add((y,xx))
            j,i=down[(y,x)]
            if grid[j][i]=='#':
                for yy in range(j+1,y):
                    res.add((yy,x))
            jj,ii=up[(y,x)]
            if grid[jj][ii]=='#':
                for yy in range(y+1,jj):
                    res.add((yy,x))
        if len(tmp)==len(res):
            for j in range(1,R+1):
                for i in range(1,C+1):
                    if grid[j][i] in ['*','#']:
                        continue
                    lj,li=left[(j,i)]
                    rj,ri=right[(j,i)]
                    leftgood=False
                    rightgood=False
                    for x in range(li+1,i):
                        if (j,x) in res:
                            leftgood=True
                            break
                    for x in range(i+1,ri):
                        if (j,x) in res:
                            rightgood=True
                            break
                    if leftgood and rightgood:
                        res.add((j,i))
                    uj,ui=up[(j,i)]
                    dj,di=down[(j,i)]
                    upgood=False
                    downgood=False
                    for y in range(dj+1,j):
                        if (y,i) in res:
                            downgood=True
                            break
                    for y in range(j+1,uj):
                        if (y,i) in res:
                            upgood=True
                            break
                    if downgood and upgood:
                        res.add((j,i))
    return res

def solv(R,C,grid):
    graph={}
    left,right,up,down={},{},{},{}
    abc=[]
    ABC=[]
    for j in range(1,R+1):
        for i in range(1,C+1):
            if grid[j][i] in ['*','#']:
                continue
            if grid[j][i].islower():
                abc.append((j,i))
            elif grid[j][i].isupper():
                ABC.append((j,i))
            x=i-1
            while grid[j][x] not in ['*','#']:
                x-=1
            left[(j,i)]=(j,x)
            xx=i+1
            while grid[j][xx] not in ['*','#']:
                xx+=1
            right[(j,i)]=(j,xx)
            y=j-1
            while grid[y][i] not in ['*','#']:
                y-=1
            down[(j,i)]=(y,i)
            yy=j+1
            while grid[yy][i] not in ['*','#']:
                yy+=1
            up[(j,i)]=(yy,i)
    res=[]
    for cell in ABC:
        tmp=canbereached(R,C,cell,left,right,up,down,grid)
        for c in abc:
            if c in tmp:
                res.append(grid[c[0]][c[1]]+grid[cell[0]][cell[1]])            
    #print(grid,abc,ABC,graph)
    #j,i=ABC[0]
    #print(grid[j][i])
    #print(left[ABC[0]],right[ABC[0]],down[ABC[0]],up[ABC[0]])
    #print(ABC[0],canbereached(R,C,ABC[0],left,right,up,down,grid))
    if len(res)==0:
        return 'NONE'
    res.sort()
    return ' '.join(res)

t = int(input()) 
for case in range(1, t+1):
    R,C = [int(s) for s in input().split()]
    maze=[['#']*(C+2)]
    for i in range(R):
        line=list(input())
        maze.append(['#']+line+['#'])
    maze.append(['#']*(C+2))
    print(f"Case #{case}: {solv(R,C,maze)}")