#include <algorithm>
#include <cassert>
#include <deque>
#include <iostream>
#include <limits>
#include <unordered_set>
#include <utility>
#include <vector>

using Board = std::vector<std::string>;

template <typename Collection>
void printCollection(const Collection& collection)
{
    for (int i = 0; i < collection.size(); i++) {
        std::cout << collection[i];
        if (i < collection.size() - 1) {
            std::cout << " ";
        }
    }
    std::cout << "\n";
}

void printBoard(const Board& board)
{
    for (const auto& row : board) {
        for (const auto tile : row) {
            std::cout << tile;
        }
        std::cout << "\n";
    }
}

// rows in range <1;500>
// cols in range <1;500>
// moves string size in range <1;300000>
std::pair<Board, std::string> getInput()
{
    int rows;
    int cols;
    std::cin >> rows;
    std::cin >> cols;
    Board b(rows, std::string(cols, '.'));
    for (int i = 0; i < rows; ++i) {
        std::cin >> b[i];
    }
    std::cin >> rows;
    std::string moves_values;
    std::cin >> moves_values;
    return std::make_pair(b, moves_values);
    // std::vector<int> v(n);
    // for (int i = 0; i < n; i++) {
    //     std::cin >> v[i];
    // }
    // return v;

    // return {{'.', '.', '.', '.', '.'},
    //         {'.', 'B', '.', 'C', '.'},
    //         {'.', '.', 'C', '.', '.'},
    //         {'.', '.', '.', 'B', '.'}};
}

std::pair<int, int> countFullRowsAndCols(Board& board)
{
    const int rows = board.size();
    const int cols = board.size() > 0 ? board[0].size() : 0;
    std::unordered_set<int> unfull_rows;
    std::unordered_set<int> unfull_cols;
    for (int row = 0; row < board.size(); ++row) {
        for (int col = 0; col < board[row].size(); ++col) {
            if (board[row][col] == '.') {
                unfull_rows.insert(row);
                unfull_cols.insert(col);
            }
        }
    }
    return std::make_pair(rows - unfull_rows.size(), cols - unfull_cols.size());
}

void moveColUp(Board& board,
               const int col,
               const int full_cols,
               const char previous_left_right_move)
{
    // check values for each column starting from the top
    int empty_idx{0};
    for (int current_row = 0; current_row < board.size(); current_row++) {
        char& current_tile = board[current_row][col];
        if (current_tile != '.') {
            std::swap(current_tile, board[empty_idx][col]);
            ++empty_idx;
        }
    }
}

void moveColDown(Board& board,
                 const int col,
                 const int full_cols,
                 const char previous_left_right_move)
{
    // check values for each column starting from the bottom
    int empty_idx{static_cast<int>(board.size()) - 1};
    for (int current_row = board.size() - 1; current_row >= 0; current_row--) {
        char& current_tile = board[current_row][col];
        if (current_tile != '.') {
            std::swap(current_tile, board[empty_idx][col]);
            --empty_idx;
        }
    }
}

void moveUpDown(Board& board,
                const char move_dir,
                const int full_cols,
                const char previous_left_right_move)
{
    const int cols = board.size() > 0 ? board[0].size() : 0;
    for (int col = 0; col < cols; ++col) {
        if (((previous_left_right_move == 'L' && col < full_cols) ||
             (previous_left_right_move == 'P' && col >= cols - full_cols))) {
            continue;
        }
        switch (move_dir) {
            case 'G':
                moveColUp(board, col, full_cols, previous_left_right_move);
                break;
            case 'D':
                moveColDown(board, col, full_cols, previous_left_right_move);
                break;
        }
    }
}

void moveRowLeft(Board& board,
                 const int row,
                 const int full_rows,
                 const char previous_up_down_move)
{
    // check values for each row starting from the left
    int empty_idx{0};
    for (int current_col = 0; current_col < board[row].size(); current_col++) {
        char& current_tile = board[row][current_col];
        if (current_tile != '.') {
            std::swap(current_tile, board[row][empty_idx]);
            ++empty_idx;
        }
    }
}

void moveRowRight(Board& board,
                  const int row,
                  const int full_rows,
                  const char previous_up_down_move)
{
    // check values for each row starting from the right
    int empty_idx{static_cast<int>(board[row].size()) - 1};
    for (int current_col = board[row].size() - 1; current_col >= 0; current_col--) {
        char& current_tile = board[row][current_col];
        if (current_tile != '.') {
            std::swap(current_tile, board[row][empty_idx]);
            --empty_idx;
        }
    }
}

void moveLeftRight(Board& board,
                   const char move_dir,
                   const int full_rows,
                   const char previous_up_down_move)
{
    for (int row = 0; row < board.size(); ++row) {
        if (((previous_up_down_move == 'G' && row < full_rows) ||
             (previous_up_down_move == 'D' && row >= board.size() - full_rows))) {
            continue;
        }
        switch (move_dir) {
            case 'L':
                moveRowLeft(board, row, full_rows, previous_up_down_move);
                break;
            case 'P':
                moveRowRight(board, row, full_rows, previous_up_down_move);
                break;
        }
    }
}

void move(Board& board, const char move_dir)
{
    static char previous_left_right_move = ' ';
    static char previous_up_down_move = ' ';
    if (previous_up_down_move != ' ' && previous_left_right_move != ' ') {
        static std::pair<int, int> rows_cols = countFullRowsAndCols(board);
        switch (move_dir) {
            case 'G':
            case 'D':
                moveUpDown(board, move_dir, rows_cols.second, previous_left_right_move);
                previous_up_down_move = move_dir;
                break;
            case 'L':
            case 'P':
                moveLeftRight(board, move_dir, rows_cols.first, previous_up_down_move);
                previous_left_right_move = move_dir;
                break;
        }
    } else {
        switch (move_dir) {
            case 'G':
            case 'D':
                moveUpDown(board, move_dir, 0, previous_left_right_move);
                previous_up_down_move = move_dir;
                break;
            case 'L':
            case 'P':
                moveLeftRight(board, move_dir, 0, previous_up_down_move);
                previous_left_right_move = move_dir;
                break;
        }
    }
}

std::string sanitizeMoves(const std::string& moves)
{
    std::string result;
    auto isOpposite = [](const char element, const char next) {
        switch (element) {
            case 'G':
                return next == 'D';
            case 'D':
                return next == 'G';
            case 'L':
                return next == 'P';
            case 'P':
                return next == 'L';
        }
        return false;
    };

    char previous_up_down = ' ';
    char previous_left_right = ' ';
    for (int i = 0; i < moves.size(); ++i) {
        if (i < moves.size() - 1 && moves[i] == moves[i + 1]) {
            continue;
        }
        if (i < moves.size() - 2 &&
            (isOpposite(moves[i], moves[i + 1]) && moves[i] == moves[i + 2])) {
            ++i;
            continue;
        }
        if (moves[i] == previous_up_down || moves[i] == previous_left_right) {
            continue;
        }
        result += moves[i];
        if (moves[i] == 'G' || moves[i] == 'D') {
            previous_up_down = moves[i];
        } else if (moves[i] == 'L' || moves[i] == 'P') {
            previous_left_right = moves[i];
        }
    }
    return result;
}

int main()
{
    // input
    auto [board, moves] = getInput();

    const auto sanitized = sanitizeMoves(moves);
    const auto sanitized2 = sanitizeMoves(sanitized);

    for (int i = 0; i < sanitized2.size(); ++i) {
        move(board, sanitized2[i]);
    }

    // output
    printBoard(board);
}