#include <cstdio>
#include <cstdlib>

int n,m,k,i,j,cnt,tmp,newinpInd;

int tab[512][512],values[550001],tab1[512][512],tab2[512][512],tab3[512][512],tab4[512][512],tab5[512][512]; 

int (*arrayp1)[512];

char inp[500005];
char newinp[500005];

void printOut(int ptab[][512]){
	int ii,jj;
	for(ii=n-1;ii>=0;ii--){
		for(jj=0;jj<m;jj++){
			if(ptab[ii][jj]==-1){
				printf(".");
			}
			else{
				printf("%c",values[ptab[ii][jj]]);
			//	ptab[ii][jj] == -1 ? printf(".") : printf("%d",ptab[ii][jj]);
			}
		}
		printf("\n");
	}
}

bool equalTabs(int inp[][512],int out[][512]){
	int ii,jj;
	for(jj = 0; jj < m ; jj++)
		for(ii = n-1;ii>=0;ii--)
			if(inp[ii][jj]!=out[ii][jj])
				return false;
		
	return true;
}


void simulateStep(int inp[][512],int out[][512],char step){
	int ii,jj,act;
	if(step=='G'){
		for(jj = 0; jj < m ; jj++){
			act = n-1;
			for(ii = n-1;ii>=0;ii--){
				if(inp[ii][jj] != -1){
					out[act--][jj] = inp[ii][jj];
				}
			}
			for(ii = act;ii>=0;ii--){
					out[ii][jj] = -1;
			}
		}
	}
	else if(step=='D'){
		for(jj = 0; jj < m ; jj++){
			act = 0;
			for(ii = 0;ii<n;ii++){
				if(inp[ii][jj] != -1){
					out[act++][jj] = inp[ii][jj];
				}
			}
			for(ii = act;ii<n;ii++){
					out[ii][jj] = -1;
			}
		}
	}
	else if(step=='L'){
		for(ii = 0; ii < n ; ii++){
			act = 0;
			for(jj = 0;jj<m;jj++){
				if(inp[ii][jj] != -1){
					out[ii][act++] = inp[ii][jj];
				}
			}
			for(jj = act;jj<m;jj++){
					out[ii][jj] = -1;
			}
		}
	}
	else if(step=='P'){
		for(ii = 0; ii < n ; ii++){
			act = m-1;
			for(jj = m-1;jj>=0;jj--){
				if(inp[ii][jj] != -1){
					out[ii][act--] = inp[ii][jj];
				}
			}
			for(jj = act;jj>=0;jj--){
					out[ii][jj] = -1;
			}
		}
	}
	else if(step=='.'){
		for(ii = 0; ii < n ; ii++){
			for(jj = 0;jj<m;jj++){
					out[ii][jj] = inp[ii][jj];
			}
		}
	}
}

int whereami1x[550005],
	whereami1y[550005],
	whereami2x[550005],
	whereami2y[550005],
	currentpermtab[550005];

int optAlgo(){
	int ii,jj,permutationStep=0,currentperm=0,iii=0,jjj=0,myval=0,permmod=0,indx=0;
//	printf("newinpInd %d\n",newinpInd);
	if(newinpInd<=8){
		for(i=0;i<=newinpInd;i++){
			if(i==0){
				simulateStep(tab,tab1,newinp[i]);
				arrayp1 = tab1;
			}
			else if(i%2){
				simulateStep(tab1,tab2,newinp[i]);
				arrayp1 = tab2;
			}
			else{
				simulateStep(tab2,tab1,newinp[i]);
				arrayp1 = tab1;
			}
		}
//		simulateStep(arrayp1,tab4,'.');
		return 1;
	}
//	printf("Execute optAlgo\n");
	simulateStep(tab,tab1,newinp[0]);
	simulateStep(tab1,tab4,newinp[1]);
	// simulate 4 steps:
	simulateStep(tab4,tab1,newinp[2]);
	simulateStep(tab1,tab2,newinp[3]);
	simulateStep(tab2,tab1,newinp[4]);
	simulateStep(tab1,tab2,newinp[5]);
		//tab2 vs tab4
	
	for(ii=0;ii<n;ii++){
		for(jj=0;jj<m;jj++){
			tab1[ii][jj]=0; // nie odwiedzone
			if(tab4[ii][jj] >= 0 && tab4[ii][jj] < 250005 ){
				whereami1x[tab4[ii][jj]]=ii;
				whereami1y[tab4[ii][jj]]=jj;
				
				whereami2x[tab2[ii][jj]]=ii;
				whereami2y[tab2[ii][jj]]=jj;
			}
		}
	}
	// wyznacz cykle permutacji
	permutationStep = (newinpInd - 1) /4;
	
	for(ii=0;ii<n;ii++){
		for(jj=0;jj<m;jj++){
			
			if(tab1[ii][jj]==0 && tab4[ii][jj]!=-1){
				currentperm=0;
				iii=ii;
				jjj=jj;
				while(tab1[iii][jjj]==0){
					currentpermtab[currentperm]=tab4[iii][jjj];
					tab1[iii][jjj]=1;
					iii=whereami2x[currentpermtab[currentperm]];
					jjj=whereami2y[currentpermtab[currentperm]];
					currentperm++;
				}
				// przemianuj
				iii=ii;
				jjj=jj;
				permmod = permutationStep % currentperm;
				
		//		printf("CP %d PS %d: ",currentperm,permutationStep);
	//			for(int iiii=0;iiii<currentperm;iiii++){
	//				printf("%d ",currentpermtab[iiii]);
	//			}
	//			printf("\n");
				
				indx = 0;
				while(tab1[iii][jjj]==1){
	//				printf("B %d ",tab4[iii][jjj]);
					tab1[iii][jjj]=2;
					
	//				printf("(%d %d %d = %d) ",indx,permutationStep,currentperm,(indx+permutationStep)%currentperm);
					// najmadrzejsza linijka w kodzie
				//	tab2[iii][jjj]=currentpermtab[(indx-(permutationStep%currentperm)+currentperm)%currentperm];
				    tab4[iii][jjj]=currentpermtab[(indx-permmod+currentperm)%currentperm];
				    
	//				printf("A %d \n",tab4[iii][jjj]);
					
					iii=whereami2x[currentpermtab[indx]];
					jjj=whereami2y[currentpermtab[indx]];
				    
					indx++;
				}
			}
		}
	}
		simulateStep(tab4,tab2,'.');
//	printf("OPTALG:\n");
//	printOut(tab4);
//	printOut(tab2);
	arrayp1 = tab2;
	// dorob koniec
	
//		printf("SS4aaaaaaaa: %d %d\n",permutationStep*4+2, newinpInd);
		
		
	for(int xi=permutationStep*4+2;xi<=newinpInd;xi++){
		
	  //	    printf("SS4111111: %d [[[[[ %c ]]]]]\n",xi,newinp[xi]);
	  	    
			if(xi%2==0){
	  //	    	printf("SS  1 \n");
				simulateStep(tab2,tab1,newinp[xi]);
				arrayp1 = tab1;
			}
			else{
	  //	    	printf("SS  2 \n");
				simulateStep(tab1,tab2,newinp[xi]);
				arrayp1 = tab2;
			}
//			printOut(arrayp1);
		}
//		printf("SS4:\n");
//		simulateStep(arrayp1,tab4,'.');
		
		
//	printf("OPTALG XXXXXXXXXX:\n");
//	printOut(tab2);
//	printf("OPTALG YYYYYYYYYYYY:\n");
//	printOut(arrayp1);
	
	return 0;
}


int algo(){
	newinp[0]=inp[0];
	newinpInd=0;
	//
	
	for(i = 1 ; i < k ; i++){
		if(newinpInd == 0){
			if(((newinp[0] == 'G' || newinp[0]=='D') && (inp[i] == 'G' || inp[i]=='D'))
			||	((newinp[0] == 'L' || newinp[0]=='P') && (inp[i] == 'L' || inp[i]=='P'))){
				newinp[0]=inp[i];
			}
			else{ // dostalismy cos w innej plaszczyznie
				newinp[++newinpInd]=inp[i];
			}
		}
		else{
			if(newinp[newinpInd] == inp[i]){ // zdublowanie - nic nie rob
			}
			else if((newinp[newinpInd] == 'G' && inp[i]=='D')||
			(newinp[newinpInd] == 'D' && inp[i]=='G')||
			(newinp[newinpInd] == 'L' && inp[i]=='P')||
			(newinp[newinpInd] == 'P' && inp[i]=='L')){
				// dostalismy oposite - mozna odwrocic
				newinpInd--;
				if(newinpInd==0){ // ale zawsze do co najmniej 2
					newinp[++newinpInd]=inp[i];
				}
			}
			else{ // dostalismy cos w innej plaszczyznie
				if(newinp[newinpInd-1]==inp[i]){// nic nie rob
				}
				else{
				newinp[++newinpInd]=inp[i];
				}
			}	
		}
	}
//	newinp[newinpInd]='G';
	
	
	optAlgo();
	simulateStep(arrayp1,tab4,'.');
	printOut(arrayp1);
	/*
	for(i=0;i<k;i++){
		if(i==0){
			simulateStep(tab,tab1,inp[i]);
			arrayp1 = tab1;
		}
		else if(i%2){
			simulateStep(tab1,tab2,inp[i]);
			arrayp1 = tab2;
		}
		else{
			simulateStep(tab2,tab1,inp[i]);
			arrayp1 = tab1;
		}
	}	
	
	
	if(!equalTabs(tab4,arrayp1)){
		/////////////////////////////
		newinp[newinpInd+1]='\n';
		printf("%s\n",inp,newinp);
		
		for(int i=0;i<=newinpInd;i++){
		printf("%c",newinp[i]);
		}
		printf("\n-----BRUT ------\n");
		////////////////////////
			printOut(tab3);
			printf("-----OPT--------------\n");
			printOut(tab4);
			printf("KURWA !!");
			return 1;
	}
	*/
	
	return 0;
}

int generateRandom(){
	printf("=======================\n");
	int ii,jj,randomN;
	n=(rand()%10)+1;
	m=(rand()%10)+1;
	;k=500000;
	cnt=0;
	for(ii=0;ii<n;ii++){
		for(jj=0;jj<m;jj++){
			randomN=rand()%3;
			if(randomN==0){
				tab[ii][jj]=-1;
			}
			else{
				if(randomN%2==1){
					values[cnt]='B';
				}else{
					values[cnt]='C';
				}
				tab[ii][jj]=cnt++;
			}
		}
	}
	for(ii=0;ii<k;ii++){
		randomN=rand()%4;
		if(randomN==0){
			inp[ii]='G';
		}
		if(randomN==1){
			inp[ii]='L';
		}
		if(randomN==2){
			inp[ii]='P';
		}
		if(randomN==3){
			inp[ii]='D';
		}
	}
	/*
	inp[0]='D';
	inp[1]='P';
	inp[2]='G';
	inp[3]='L';
	inp[0+4]='D';
	inp[1+4]='P';
	inp[2+4]='G';
	inp[3+4]='L';
	inp[0+8]='D';
	inp[1+8]='P';
	inp[2+8]='G';
	inp[3+8]='L';
	inp[0+12]='D';
	inp[1+12]='P';
	inp[2+12]='G';
	inp[3+12]='L';
	inp[0+16]='D';
	inp[1+16]='P';
	inp[2+16]='G';
	inp[3+16]='L';
	*/
	/*
	inp[0]='P';
	inp[1]='G';
	inp[2]='L';
	inp[3]='D';
	inp[0+4]='P';
	inp[1+4]='G';
	inp[2+4]='L';
	inp[3+4]='D';
	inp[0+8]='P';
	inp[1+8]='G';
	inp[2+8]='L';
	inp[3+8]='D';
	inp[0+12]='P';
	inp[1+12]='G';
	inp[2+12]='L';
	inp[3+12]='D';
	inp[0+16]='P';
	inp[1+16]='G';
	inp[2+16]='L';
	inp[3+16]='D';
	*/
	
}

int main(){
	
	scanf("%d%d",&n,&m);
	cnt=0;
	for(i=n-1;i>=0;i--){
		scanf("%s",inp);
		for(j=0;j<m;j++){
			if(inp[j] =='.'){
				tab[i][j] = -1;
			}
			else{
				tab[i][j]=cnt;
				values[cnt++]=inp[j];
			}
		}
	}
	//
	scanf("%d",&k);
	scanf("%s",inp);
	
	algo();
	
	/*
	int res = 0;
	while(res==0){
		generateRandom();
		res = algo();
	}
	*/
	

}