import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.ArrayList; 
import java.util.Iterator; 
import java.util.Scanner; 


public class Main { 

private static int numLetrasPosibles = 28; 
private static char[][] tabla; 
private static int m = 0; 
private static int n = 0; 
private static String[] palabras; 
private static ArrayList<Integer>[] posicionesPorLetra = new ArrayList[numLetrasPosibles]; 

/** 
* Método inicial. 
* 
* @param args 
*            argumentos. 
* @throws IOException 
*             si falla. 
*/ 
public static void main(String[] args) throws IOException { 

// Scanner para la entrada. 
Scanner in = new Scanner(new BufferedReader(new InputStreamReader( 
System.in))); 
int numCasos = leerNum(in); 

// Para cada caso 
for (int i = 0; i < numCasos; i++) { 
// linea en blanco 
in.nextLine().split(" "); 
// leo my x. 
int[] tamanyo = leer2Num(in); 
m = tamanyo[0]; 
n = tamanyo[1]; 
// inicializar la tabla 
tabla = new char[m][n]; 
// leo la tabla. 
leerTabla(); 
// inicializar array 
inicializarPoscionesPorLetra(); 
// Inicializo las posiciones en que aparece cada caracter. 
inicializarCuentas(); 

// leer num palabras 
int numPalabras = leerNum(in); 

// inicializo array de palabras. 
palabras = new String[numPalabras]; 

// leer las palabras 
for (int k = 0; k < numPalabras; k++) { 
String palabraKesima = readLine(); 
palabraKesima = palabraKesima.toLowerCase(); 
palabras[k] = palabraKesima; 
} 

// buscar 
// para cada palabra 

for (int k = 0; k < numPalabras; k++) { 
char[] palabra = palabras[k].toCharArray(); 
// para cada posicion que está laprimera letra 
Iterator<Integer> it = posicionesPorLetra[(int) palabra[0] - 97] 
.iterator(); 
// sobraría xk siempre está la palabra 
// tener k buskar.. 
while (it.hasNext()) { 
int fila = ((Integer) (it.next())).intValue(); 
int columna = ((Integer) (it.next())).intValue(); 
int[] valido = null; 
if (palabra.length > 1) { 
valido = buscar(palabra, fila, columna); 
}else{ 
valido[0]=fila; 
valido[1]=columna; 
} 
// si valido entonces salir 
if (valido[0] != -1 && valido[1] != -1) { 
valido[0]++; 
valido[1]++; 
System.out.println(valido[0] + " " + valido[1]); 
break; 
} 

} 
} 
if (numCasos > 1) { 
System.out.println(""); 
} 

} 

} 

private static int[] buscar(char[] palabra, int fila, int columna) { 
int[] num = { -1, -1 }; 

int i, j = 0; 
i = fila; 
j = columna; 
boolean encontrado = true; 

// buscar hacia la derecha 
encontrado = true; 
j = columna; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (j + 1 > n - 1) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[i][++j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 

// buscar diagonal bajando hacia derecha 
encontrado = true; 
j = columna; 
i = fila; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (i + 1 > m - 1 || j + 1 > n - 1) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[++i][++j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 

// buscar hacia abajo 
encontrado = true; 
j = columna; 
i = fila; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (i + 1 > m - 1) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[++i][j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 

// buscar diagonal bajando hacia izq 
encontrado = true; 
j = columna; 
i = fila; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (i + 1 > m - 1 || j - 1 < 0) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[++i][--j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 
// buscar hacia la izq 
encontrado = true; 
i = fila; 
j = columna; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (j - 1 < 0) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[i][--j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 
// buscar diagonal subiendo hacia izq 
encontrado = true; 
j = columna; 
i = fila; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (i - 1 < 0 || j - 1 < 0) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[--i][--j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 
// buscar hacia arriba 
encontrado = true; 
j = columna; 
i = fila; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (i - 1 < 0) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[--i][j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 
// buscar diagonal subiendo hacia derecha 
encontrado = true; 
j = columna; 
i = fila; 
for (int k = 1; k < palabra.length; k++) { 
// Para que no se salga buscando.. 
if (i - 1 < 0 || j + 1 > n - 1) { 
encontrado = false; 
break; 
} 
if (palabra[k] != tabla[--i][++j]) { 
encontrado = false; 
break; 
} 
} 
if (true == encontrado) { 
num[0] = fila; 
num[1] = columna; 
return num; 
} 

return num; 

} 

private static String readLine() { 
StringBuffer sb = new StringBuffer(""); 
int b = 0; 
while (b != '\n' && b >= 0) { 
try { 
b = System.in.read(); 
} catch (IOException e) { 
return null; 
} 
if (b != '\r' && b != '\n' && b >= 0) 
sb.append((char) b); 
} 
if (sb.length() == 0 && b < 0) 
return null; 
return sb.toString().trim(); 
} 

/** 
* Inicializa posicionesPorLetra. 
* 
* @param m 
*            filas de la tabla. 
* @param n 
*            columnas de la tabla. 
*/ 
private static void inicializarCuentas() { 

for (int i = 0; i < m; i++) { 
for (int j = 0; j < n; j++) { 

posicionesPorLetra[(int) tabla[i][j] - 97].add(i); 
posicionesPorLetra[(int) tabla[i][j] - 97].add(j); 
} 
} 

} 

/** 
* Lee de fila en fila la tabla. 
* 
* @param m 
*            filas. 
*/ 
private static void leerTabla() { 

// leer la matriz 
for (int k = 0; k < m; k++) { 
String filaKesima = readLine(); 
filaKesima = filaKesima.toLowerCase(); 
// guardarlo en un array... 
tabla[k] = filaKesima.toCharArray(); 

} 
} 

/** 
* Inicializa el array de posicionesPorLetra. 
*/ 
private static void inicializarPoscionesPorLetra() { 
for (int k = 0; k < numLetrasPosibles; k++) { 
posicionesPorLetra[k] = new ArrayList<Integer>(); 
} 
} 

private static int leerNum(Scanner in) { 
String[] numeros = in.nextLine().split(" "); 
int index = 0; 
int num = 0; 
for (; index < numeros.length; index++) { 
try { 
num = Integer.parseInt(numeros[index]); 
break; 
} catch (final NumberFormatException e) { 
// Si falla. 
} 

} 
return num; 
} 

private static int[] leer2Num(Scanner in) { 
int[] num = { 0, 0 }; 
String[] numeros; 
// leo myn 
numeros = in.nextLine().split(" "); 
int index = 0; 
int m = 0; 
for (; index < numeros.length; index++) { 
try { 
m = Integer.parseInt(numeros[index]); 
break; 
} catch (final NumberFormatException e) { 
// Si falla. 
} 

} 
index++; 
int n = 0; 
for (; index < numeros.length; index++) { 
try { 
n = Integer.parseInt(numeros[index]); 
break; 
} catch (final NumberFormatException e) { 
// Si falla. 
} 
} 
num[0] = m; 
num[1] = n; 
return num; 

} 
}