#include <iostream>
#include <deque>

using namespace std;

enum class Edge { UP_LEFT, UP_RIGHT, DOWN_LEFT, DOWN_RIGHT };
enum class Direction { UP, DOWN, LEFT, RIGHT };
enum class Rotation { CLOCKWISE, COUNTER };

Direction get_dir(char c) {

	switch(c) {
		case 'G': return Direction::UP;
		case 'D': return Direction::DOWN;
		case 'L': return Direction::LEFT;
		default : return Direction::RIGHT;
	}
}

bool is_edge(Direction dir1, Direction dir2) {
	if (dir1 == Direction::UP || dir1 == Direction::DOWN)
		return dir2 == Direction::LEFT || dir2 == Direction::RIGHT;
	else
		return dir2 == Direction::UP || dir2 == Direction::DOWN;
}

Edge get_edge(Direction dir1, Direction dir2) {

	switch(dir1) {
	case Direction::UP: 
		if (dir2 == Direction::LEFT) return Edge::UP_LEFT; else return Edge::UP_RIGHT;
	case Direction::DOWN: 
		if (dir2 == Direction::LEFT) return Edge::DOWN_LEFT; else return Edge::DOWN_RIGHT;
	case Direction::LEFT:
		if (dir2 == Direction::UP) return Edge::UP_LEFT; else return Edge::DOWN_LEFT;
	default:
		if (dir2 == Direction::UP) return Edge::UP_RIGHT; else return Edge::DOWN_RIGHT;
	}
}

Rotation get_rotation(Edge edge, char c) {
	switch(edge) {
	case Edge::UP_RIGHT: if (c == 'D') return Rotation::CLOCKWISE; else return Rotation::COUNTER;
	case Edge::UP_LEFT: if (c == 'D') return Rotation::COUNTER; else return Rotation::CLOCKWISE;
	case Edge::DOWN_LEFT: if (c == 'G') return Rotation::CLOCKWISE; else return Rotation::COUNTER;
	default: if (c == 'G') return Rotation::COUNTER; else return Rotation::CLOCKWISE;
	}
}

Edge move_edge(char c, Edge edge) {

	switch(edge) {
		case Edge::UP_LEFT:
			if (c == 'P') return Edge::UP_RIGHT;
			else if (c == 'D') return Edge::DOWN_LEFT;
			else return Edge::UP_LEFT;
		case Edge::UP_RIGHT:
			if (c == 'L') return Edge::UP_LEFT;
			else if (c == 'D') return Edge::DOWN_RIGHT;
			else return Edge::UP_RIGHT;
		case Edge::DOWN_LEFT:
			if (c == 'P') return Edge::DOWN_RIGHT;
			else if (c == 'G') return Edge::UP_LEFT;
			else return Edge::DOWN_LEFT;
		default:
			if (c == 'L') return Edge::DOWN_LEFT;
			else if (c == 'G') return Edge::UP_RIGHT;
			else return Edge::DOWN_RIGHT;
	}
}

void up(char *board[], int n, int m) {
	for (int j = 0; j < m; j++) {
		int first_empty = 0;
		for (int i = 0; i < n; i++) 
			if (board[i][j] != '.')
				board[first_empty++][j] = board[i][j];

		for (int i = first_empty; i < n; i++)
			board[i][j] = '.';
	}
}

void down(char *board[], int n, int m) {
	for (int j = 0; j < m; j++) {
		int first_empty = n-1;
		for (int i = n-1; i >= 0; i--) 
			if (board[i][j] != '.')
				board[first_empty--][j] = board[i][j];

		for (int i = first_empty; i >= 0; i--)
			board[i][j] = '.';
	}
}

void left(char *board[], int n, int m) {
	for (int i = 0; i < n; i++) {
		int first_empty = 0;
		for (int j = 0; j < m; j++)
			if (board[i][j] != '.')
				board[i][first_empty++] = board[i][j];

		for (int j = first_empty; j < m; j++)
			board[i][j] = '.';
	}
}

void right(char *board[], int n, int m) {
	for (int i = 0; i < n; i++) {
		int first_empty = m-1;
		for (int j = m-1; j >= 0; j--)
			if (board[i][j] != '.')
				board[i][first_empty--] = board[i][j];

		for (int j = first_empty; j >= 0; j--)
			board[i][j] = '.';
	}
}

void print_board(char *board[], int n, int m) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			cout << board[i][j];
		}
		cout << "\n";
	}
}

void print_board_int(int *board[], int n, int m) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			cout << board[i][j] << "\t";
		}
		cout << "\n";
	}
}

void move(char *board[], int n, int m, Direction dir) {
	switch(dir) {
	case Direction::UP: up(board, n, m); break;
	case Direction::DOWN: down(board, n, m); break;
	case Direction::LEFT: left(board, n, m); break;
	default: right(board, n, m); break;
	}
}

void start_position(char *board[], int n, int m, Direction dir1, Direction dir2) {
	move(board, n, m, dir1);
	move(board, n, m, dir2);
}

void get_permutation_board(int *permutation_board[], char *board[], int n, int m) {
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			if (board[i][j] != '.')
				permutation_board[i][j] = i*m+j;
			else
				permutation_board[i][j] = -1;
}

void up_int(int *board[], int n, int m) {
	for (int j = 0; j < m; j++) {
		int first_empty = 0;
		for (int i = 0; i < n; i++) 
			if (board[i][j] != -1)
				board[first_empty++][j] = board[i][j];

		for (int i = first_empty; i < n; i++)
			board[i][j] = -1;
	}
}

void down_int(int *board[], int n, int m) {
	for (int j = 0; j < m; j++) {
		int first_empty = n-1;
		for (int i = n-1; i >= 0; i--) 
			if (board[i][j] != -1)
				board[first_empty--][j] = board[i][j];

		for (int i = first_empty; i >= 0; i--)
			board[i][j] = -1;
	}
}

void left_int(int *board[], int n, int m) {
	for (int i = 0; i < n; i++) {
		int first_empty = 0;
		for (int j = 0; j < m; j++)
			if (board[i][j] != -1)
				board[i][first_empty++] = board[i][j];

		for (int j = first_empty; j < m; j++)
			board[i][j] = -1;
	}
}

void right_int(int *board[], int n, int m) {
	for (int i = 0; i < n; i++) {
		int first_empty = m-1;
		for (int j = m-1; j >= 0; j--)
			if (board[i][j] != -1)
				board[i][first_empty--] = board[i][j];

		for (int j = first_empty; j >= 0; j--)
			board[i][j] = -1;
	}
}


void rotate(int *board[], int n, int m, Edge edge, Rotation rotation) {

	switch (edge) {
	case Edge::UP_RIGHT: 
		if (rotation == Rotation::CLOCKWISE) {
			down_int(board, n, m);
			left_int(board, n, m);
			up_int(board, n, m);
			right_int(board, n, m);
		}
		else {
			left_int(board, n, m);
			down_int(board, n, m);
			right_int(board, n, m);
			up_int(board, n, m);
		}
		break;
	case Edge::DOWN_RIGHT: 
		if (rotation == Rotation::CLOCKWISE) {
			left_int(board, n, m);
			up_int(board, n, m);
			right_int(board, n, m);
			down_int(board, n, m);
		}
		else {
			up_int(board, n, m);
			left_int(board, n, m);
			down_int(board, n, m);
			right_int(board, n, m);			
		}
		break;
	case Edge::DOWN_LEFT:
		if (rotation == Rotation::CLOCKWISE) {
			up_int(board, n, m);
			right_int(board, n, m);
			down_int(board, n, m);
			left_int(board, n, m);
		}
		else {
			right_int(board, n, m);	
			up_int(board, n, m);
			left_int(board, n, m);
			down_int(board, n, m);
		}
		break;
	default: 
		if (rotation == Rotation::CLOCKWISE) {
			right_int(board, n, m);
			down_int(board, n, m);
			left_int(board, n, m);
			up_int(board, n, m);
		}
		else {
			down_int(board, n, m);
			right_int(board, n, m);	
			up_int(board, n, m);
			left_int(board, n, m);
		}
		break;
	}
}

void apply_permutation(char *board[], int *permutation[], int n, int m) {

	char *tmp[n];
	for (int i = 0; i < n; i++)
		tmp[i] = new char[m];

	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			tmp[i][j] = board[i][j];

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			int num = permutation[i][j];
			if (num != -1)
				board[i][j] = tmp[num/m][num%m]; 
		}
	}
}

void power_permutation(int *permutation[], int n, int m) {

	int *tmp[n];
	for (int i = 0; i < n; i++)
		tmp[i] = new int[m];

	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			tmp[i][j] = permutation[i][j];

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			int num = tmp[i][j];
			if (num != -1)
				permutation[i][j] = tmp[num/m][num%m]; 
		}
	}
}

int main() {

	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int n, m;
	cin >> n >> m;

	char *board[n];
	for (int i = 0; i < n; i++)
		board[i] = new char[m];

	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++) {
		cin >> board[i][j];
	}

	int k;
	cin >> k;
	char moves[k];
	for (int i = 0; i < k; i++)
		cin >> moves[i];

	Direction dir1, dir2 = get_dir(moves[0]);
	int i = 1;
	bool end = i >= k;
	while (!end) {
		dir1 = dir2;
		dir2 = get_dir(moves[i++]);
		end = i >= k || is_edge(dir1, dir2);
	}

	if (!is_edge(dir1, dir2)) {
		move(board, n, m, dir2);
		print_board(board, n, m);
		return 0;
	}

	start_position(board, n, m, dir1, dir2);

	Edge edge, start_edge = get_edge(dir1, dir2);
	edge = start_edge;
	deque<int> compressed;
	for (; i < k; i++) {
		if (edge == move_edge(moves[i], edge)) continue;
		if (!compressed.empty()) {
			if ((moves[i] == 'L' && compressed.back() == 'P') ||
				(moves[i] == 'G' && compressed.back() == 'D') ||
				(moves[i] == 'P' && compressed.back() == 'L') ||
				(moves[i] == 'D' && compressed.back() == 'G')) {
				edge = move_edge(moves[i], edge);
				compressed.pop_back();
				continue;
			}
		}
		compressed.push_back(moves[i]);
		edge = move_edge(moves[i], edge);
	}

	Rotation rotation = get_rotation(start_edge, compressed.front());

	int *permutation_board[n];
	for (int i = 0; i < n; i++)
		permutation_board[i] = new int[m];

	get_permutation_board(permutation_board, board, n, m);

	rotate(permutation_board, n, m, start_edge, rotation);

	int l = compressed.size()/4;

	while (l > 0) {
		if (l % 2 == 1)
			apply_permutation(board, permutation_board, n, m);

		l /= 2;
		power_permutation(permutation_board, n, m);
	}

	while (compressed.size() >= 4) {
		for (int i = 0; i < 4; i++)
			compressed.pop_front();
	}

	for (char c : compressed) {
		switch(c) {
		case 'G': up(board, n, m); break;
		case 'D': down(board, n, m); break;
		case 'L': left(board, n, m); break;
		default : right(board, n, m); break;
		}
	}
	
	print_board(board, n, m);	

	return 0;
}