import java.util.Scanner;

/**
 * Replace this JavaDoc comment for the purpose of this class
 */
public class Solution
{
	/**
	 * Gets data from standard input
	 */
	private Scanner input = null;

	/**
	 * Start the execution of the solution
	 * @param args Command line arguments
	 */
	public static void main(String args[])
	{
		Solution solution = new Solution();
		solution.run();
	}

	/**
	 * Run the solution. This method is called from main()
	 */
	public void run()
	{
		// Create object to read data from standard input
		this.input = new Scanner(System.in);

		// Leer las dimensiones
		int filas = this.input.nextInt();
		int columnas = this.input.nextInt();

		// Leer la cantidad de medianoches
		int medianoches = this.input.nextInt();

		// Ignorar los dos cambios de linea despues de los numeros
		this.input.nextLine();
		this.input.nextLine();

		// Crear un bosque de acuerdo a las dimensiones
		char[][] bosque = new char[filas][columnas];

		// Leer el bosque
		leerBosque(bosque);

		// Simular el numero de medinoches e imprimirlas
		simularMedianoches(bosque, medianoches);

		// Close the standard input
		this.input.close();
	}

	public void leerBosque(char[][] bosque)
	{
		// Leer una letra a la vez
		this.input.useDelimiter("");

		// Leer las filas
		for ( int fila = 0; fila < bosque.length; ++fila )
		{
			// Leer las columnas
			for ( int columna = 0; columna < bosque[fila].length; ++columna )
			{
				bosque[fila][columna] = this.input.next().charAt(0);
			}

			// Ignorar el cambio de linea
			this.input.nextLine();
		}
	}

	public void imprimirBosque(char[][] bosque, int dia)
	{
		// Imprimir el numero de dia
		System.out.printf("%d:\n", dia);

		// Imprimir filas
		for ( int fila = 0; fila < bosque.length; ++fila )
		{
			// Imprimir columnas
			for ( int columna = 0; columna < bosque[fila].length; ++columna )
			{
				System.out.print(bosque[fila][columna]);
			}

			// Separar de la proxima fila
			System.out.println();
		}
	}

	public void simularMedianoches(char[][] bosque, int medianoches)
	{
		// Imprimir el bosque en el dia 0
		imprimirBosque(bosque, 0);

		// Repetir por cada medianoche (valor absoluto)
		for ( int medianoche = 1; medianoche <= Math.abs(medianoches); ++medianoche)
		{
			// Aplicar las reglas al bosque
			// y reemplazarlo por el nuevo bosque tras aplicarle las reglas
			bosque = aplicarReglas(bosque);

			// Si medianoches es positivo o el contador es igual medianoches
			if ( medianoches > 0 || medianoche == Math.abs(medianoches) )
			{
				// Separar este bosque del anterior
				System.out.println();

				// Imprimir el bosque
				imprimirBosque(bosque, medianoche);
			}
		}
	}

	public char[][] aplicarReglas(char[][] bosqueDiaAnterior)
	{
		// Crear un bosque para el dia siguiente
		char[][] bosqueDiaSiguiente = new char[bosqueDiaAnterior.length][bosqueDiaAnterior[0].length];

		// Recorrer todas las celdas del bosque y actualizarlas
		for ( int fila = 0; fila < bosqueDiaAnterior.length; ++fila )
		{
			for ( int columna = 0; columna < bosqueDiaAnterior[fila].length; ++columna )
			{
				// Actualizar la celda en la nueva matriz aplicando las reglas
				aplicarReglas( fila, columna, bosqueDiaAnterior, bosqueDiaSiguiente );
			}
		}

		// Retornar una referencia al nuevo bosque
		return bosqueDiaSiguiente;
	}

	public void aplicarReglas( int fila, int columna, char[][] bosqueDiaAnterior, char[][] bosqueDiaSiguiente )
	{
		// Contar los vecinos de cada tipo
		int arboles = contarVecinos(fila, columna, bosqueDiaAnterior, 'a');
		int lagos = contarVecinos(fila, columna, bosqueDiaAnterior, 'l');

		// Aplicar la regla de inundacion
		if ( bosqueDiaAnterior[fila][columna] == 'a' && lagos >= 4 )
			bosqueDiaSiguiente[fila][columna] = 'l';
		// Aplicar la regla de sequia
		else if ( bosqueDiaAnterior[fila][columna] == 'l' && lagos < 3 )
			bosqueDiaSiguiente[fila][columna] = '-';
		// Aplicar la regla de refosteracion
		else if ( bosqueDiaAnterior[fila][columna] == '-' && arboles >= 3 )
			bosqueDiaSiguiente[fila][columna] = 'a';
		// Aplicar la regla de hacinamiento
		else if ( bosqueDiaAnterior[fila][columna] == 'a' && arboles > 4 )
			bosqueDiaSiguiente[fila][columna] = '-';
		// Aplicar la regla de estabilidad
		else
			bosqueDiaSiguiente[fila][columna] = bosqueDiaAnterior[fila][columna];
	}

	public int contarVecinos(int fila, int columna, char[][] bosque, char tipoVecino)
	{
		// Cuenta la cantidad de ocurrencias de tipoVecino
		int cantidad = 0;

		// Contar tipoVecino en las 8 celdas alrededor de bosque[fila][columna]
		if ( valorCelda(fila - 1, columna - 1, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila - 1, columna + 0, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila - 1, columna + 1, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila + 0, columna - 1, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila + 0, columna + 1, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila + 1, columna - 1, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila + 1, columna + 0, bosque) == tipoVecino ) ++cantidad;
		if ( valorCelda(fila + 1, columna + 1, bosque) == tipoVecino ) ++cantidad;

		return cantidad;
	}

	char valorCelda(int fila, int columna, char[][] bosque)
	{
		// Si la celda existe, retornar su valor
		if ( fila >= 0 && fila < bosque.length && columna >= 0 && columna < bosque[0].length )
			return bosque[fila][columna];

		// La celda no existe, retornar un valor no valido
		return '\0';
	}
}