import java.io.BufferedReader;
import java.io.InputStreamReader;


public class Dive {

	public static void main(String[] args) {
		BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
		
		try {
			
			boolean run = true;
			String line;
			while (((line = bfr.readLine()) != null) && run) {
				String[] lineEl = line.split(" ");
				int rowCount = Integer.parseInt(lineEl[0]);
				int colCount = Integer.parseInt(lineEl[1]);
				if (rowCount == 0 && colCount == 0) {
					break;
				}
				
				char falconChar = lineEl[2].charAt(1);
				char[][] original = new char[rowCount][colCount];
				char[][] image = new char[rowCount][colCount];
				char[][] backGround = new char[rowCount][colCount];
				char[][] result = new char[rowCount][colCount];
				
				boolean[][] diffs = new boolean[rowCount][colCount];
				int diffsCount = 0;
				int falconChars = 0;

				int minRowOr, minColOr, maxColOr, maxRowOr;
				minColOr = colCount - 1;
				minRowOr = rowCount - 1;
				maxColOr = 0;
				maxRowOr = 0;
				
				int minColIm, maxColIm, maxRowIm, minRowIm;
				minColIm = colCount - 1;
				minRowIm = rowCount - 1;
				maxColIm = 0;
				maxRowIm = 0;
				
				int rowMove, colMove;
				
				
				for (int k = 0; k < 2; k++) {
					for (int i = 0; i < rowCount; i++) {
						String row = bfr.readLine();
						
						for (int j = 0; j < colCount; j++) {
							char currChar = row.charAt(j);
						
							//background chars
							if (currChar != falconChar) {
								backGround[i][j] = currChar;
							}
							
							//original cycle
							if (k == 0) {
								original[i][j] = currChar;
								
								if (currChar == falconChar){
									falconChars++;
								}
								
								if (currChar == falconChar) {
									if (i > maxRowOr) {
										maxRowOr = i;
									} 
									
									if (i < minRowOr) {
										minRowOr = i;
									}
									
									if (j > maxColOr) {
										maxColOr = j;
									}
									
									if (j < minColOr) {
										minColOr = j;
									}
								}
							} else {
								image[i][j] = currChar;
								
								if (original[i][j] != image[i][j]) {
									diffs[i][j] = true;
									diffsCount++;
								} else {
									diffs[i][j] = false;
								}
								
								if (currChar == falconChar) {
									if (i > maxRowIm) {
										maxRowIm = i;
									} 
									
									if (i < minRowIm) {
										minRowIm = i;
									}
									
									if (j > maxColIm) {
										maxColIm = j;
									}
									
									if (j < minColIm) {
										minColIm = j;
									}
								}
							}

						}
					}
					bfr.readLine();
				}
				
				//there is no falcon in silluethe
				if (diffsCount == falconChars) {
					printCharField(image);
				} else {
					
					//we need to catch correct corner
					int currRowOr, currColOr;
					int currRowRes, currColRes;
				
					//top-left corner
					rowMove = minRowOr - minRowIm;
					colMove = minColOr - minColIm;
					
					boolean allOk = true;
					copyFiels(backGround, result);
					for (int i = minRowIm; i <= maxRowIm && allOk; i++) {
						currRowOr = i + rowMove;
						currRowRes = i - rowMove;
						
						for (int j = minColIm; j <= maxColIm && allOk; j++) {
							currColOr = j + colMove;
							currColRes = j - colMove;
							
							//we didnt exceeded original field borders
							if (isInBorders(currRowOr, currColOr, rowCount, colCount)) {
								if (((image[i][j] == falconChar) && (original[currRowOr][currColOr] != falconChar))
										|| ((image[i][j] != falconChar) && (original[currRowOr][currColOr] == falconChar))) {
									allOk = false;
								} else {
									if (isInBorders(currRowRes, currColRes, rowCount, colCount)) {
										if (image[i][j] == falconChar) {
											result[currRowRes][currColRes] = falconChar;
										}
									}
								}
							
							}
						}
					}
					
					//we found a solution
					if (allOk) {
						printCharField(result);
						break;
					}
					
					//top-right corner
					rowMove = minRowOr - minRowIm;
					colMove = maxColOr - maxColIm;
					
					allOk = true;
					copyFiels(backGround, result);
					for (int i = minRowIm; i <= maxRowIm && allOk; i++) {
						currRowOr = i + rowMove;
						currRowRes = i - rowMove;
						
						for (int j = minColIm; j <= maxColIm && allOk; j++) {
							currColOr = j + colMove;
							currColRes = j - colMove;
							
							//we didnt exceeded original field borders
							if (isInBorders(currRowOr, currColOr, rowCount, colCount)) {
								if (((image[i][j] == falconChar) && (original[currRowOr][currColOr] != falconChar))
										|| ((image[i][j] != falconChar) && (original[currRowOr][currColOr] == falconChar))) {
									allOk = false;
								} else {
									if (isInBorders(currRowRes, currColRes, rowCount, colCount)) {
										if (image[i][j] == falconChar) {
											result[currRowRes][currColRes] = falconChar;
										}
									}
								}
							
							}
						}
					}
					
					//we found a solution
					if (allOk) {
						printCharField(result);
						break;
					}
					
					//bottom-left corner
					rowMove = maxRowOr - maxRowIm;
					colMove = minColOr - minColIm;
					
					allOk = true;
					copyFiels(backGround, result);
					for (int i = minRowIm; i <= maxRowIm && allOk; i++) {
						currRowOr = i + rowMove;
						currRowRes = i - rowMove;
						
						for (int j = minColIm; j <= maxColIm && allOk; j++) {
							currColOr = j + colMove;
							currColRes = j - colMove;
							
							//we didnt exceeded original field borders
							if (isInBorders(currRowOr, currColOr, rowCount, colCount)) {
								if (((image[i][j] == falconChar) && (original[currRowOr][currColOr] != falconChar))
										|| ((image[i][j] != falconChar) && (original[currRowOr][currColOr] == falconChar))) {
									allOk = false;
								} else {
									if (isInBorders(currRowRes, currColRes, rowCount, colCount)) {
										if (image[i][j] == falconChar) {
											result[currRowRes][currColRes] = falconChar;
										}
									}
								}
							
							}
						}
					}
					
					//we found a solution
					if (allOk) {
						printCharField(result);
						break;
					}
					
					//bottom-right corner
					rowMove = maxRowOr - maxRowIm;
					colMove = maxColOr - maxColIm;
					
					allOk = true;
					copyFiels(backGround, result);
					for (int i = minRowIm; i <= maxRowIm && allOk; i++) {
						currRowOr = i + rowMove;
						currRowRes = i - rowMove;
						
						for (int j = minColIm; j <= maxColIm && allOk; j++) {
							currColOr = j + colMove;
							currColRes = j - colMove;
							
							//we didnt exceeded original field borders
							if (isInBorders(currRowOr, currColOr, rowCount, colCount)) {
								if (((image[i][j] == falconChar) && (original[currRowOr][currColOr] != falconChar))
										|| ((image[i][j] != falconChar) && (original[currRowOr][currColOr] == falconChar))) {
									allOk = false;
								} else {
									if (isInBorders(currRowRes, currColRes, rowCount, colCount)) {
										if (image[i][j] == falconChar) {
											result[currRowRes][currColRes] = falconChar;
										}
									}
								}
							
							}
						}
					}
					
					//we found a solution
					if (allOk) {
						printCharField(result);
						break;
					}
					
					
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public static boolean isInBorders(int row, int col, int rowLimit, int colLimit) {
		return row >= 0 && row < rowLimit && col >= 0 && col < colLimit;
	}
	
	public static void copyFiels(char[][] fromField, char[][] toField) {
		for (int i = 0; i < fromField.length; i++) {
			for (int j = 0; j < fromField[0].length; j++) {
				toField[i][j] = fromField[i][j];
			}
		}
		
	}
	
	public static void printCharField(char[][] field) {
		for (int i = 0; i < field.length; i++) {
			for (int j = 0; j < field[0].length; j++) {
				System.out.print(field[i][j]);
			}
			System.out.println();
		}
		
		System.out.println();
	}
}