#include <iostream>
#include <climits>

#define QUARTERS 4

using namespace std;

enum placement_t : int
{
    initial = 0,
    up = 1,
    down = 2,
    left = 4,
    right = 8,
    up_left = placement_t::up | placement_t::left,
    up_right = placement_t::up | placement_t::right,
    down_left = placement_t::down | placement_t::left,
    down_right = placement_t::down | placement_t::right
};

enum move_t : int
{
    clockwise = 1,
    counterclockwise = -1,
    swap = 0
};

placement_t from_move_and_placement(char move, placement_t prev_placement)
{
    switch (move)
    {
    case 'G':
        return static_cast<placement_t>((prev_placement & (placement_t::left | placement_t::right)) | placement_t::up);
    case 'D':
        return static_cast<placement_t>((prev_placement & (placement_t::left | placement_t::right)) | placement_t::down);
    case 'L':
        return static_cast<placement_t>((prev_placement & (placement_t::up | placement_t::down)) | placement_t::left);
    case 'P':
        return static_cast<placement_t>((prev_placement & (placement_t::up | placement_t::down)) | placement_t::right);
    }
    return placement_t::initial;
}

move_t get_move_type(placement_t prev, placement_t next)
{
    const placement_t product = static_cast<placement_t>(prev & next);

    switch (product)
    {
    case placement_t::initial:
        return move_t::swap;
    case placement_t::up:
        return (next & placement_t::right) ? move_t::clockwise : move_t::counterclockwise;
    case placement_t::down:
        return (next & placement_t::left) ? move_t::clockwise : move_t::counterclockwise;
    case placement_t::left:
        return (next & placement_t::up) ? move_t::clockwise : move_t::counterclockwise;
    case placement_t::right:
        return (next & placement_t::down) ? move_t::clockwise : move_t::counterclockwise;
    }
    return move_t::swap;
}

template <class T, T empty>
void move_left(T **board, int n, int m)
{
    for (int j = 1; j < m; ++j)
    {
        for (int i = 0; i < n; ++i)
        {
            if (board[i][j] != empty)
            {
                int p = j;
                while (p > 0 && board[i][p - 1] == empty)
                {
                    board[i][p - 1] = board[i][p];
                    board[i][p] = empty;
                    --p;
                }
            }
        }
    }
}

template <class T, T empty>
void move_right(T **board, int n, int m)
{
    for (int j = m - 2; j >= 0; --j)
    {
        for (int i = 0; i < n; ++i)
        {
            if (board[i][j] != empty)
            {
                int p = j;
                while (p < m - 1 && board[i][p + 1] == empty)
                {
                    board[i][p + 1] = board[i][p];
                    board[i][p] = empty;
                    ++p;
                }
            }
        }
    }
}

template <class T, T empty>
void move_up(T **board, int n, int m)
{
    for (int i = 1; i < n; ++i)
    {
        for (int j = 0; j < m; ++j)
        {
            if (board[i][j] != empty)
            {
                int p = i;
                while (p > 0 && board[p - 1][j] == empty)
                {
                    board[p - 1][j] = board[p][j];
                    board[p][j] = empty;
                    --p;
                }
            }
        }
    }
}

template <class T, T empty>
void move_down(T **board, int n, int m)
{
    for (int i = n - 1; i >= 0; --i)
    {
        for (int j = 0; j < m; ++j)
        {
            if (board[i][j] != empty)
            {
                int p = i;
                while (p < n - 1 && board[p + 1][j] == empty)
                {
                    board[p + 1][j] = board[p][j];
                    board[p][j] = empty;
                    ++p;
                }
            }
        }
    }
}

template <class T, T empty>
void move_by_char(T **board, int n, int m, char move)
{
    // cout << "Move " << move << endl;
    switch (move)
    {
    case 'G':
        move_up<T, empty>(board, n, m);
        break;
    case 'D':
        move_down<T, empty>(board, n, m);
        break;
    case 'L':
        move_left<T, empty>(board, n, m);
        break;
    case 'P':
        move_right<T, empty>(board, n, m);
        break;
    }
}

char clockwise_move(placement_t p)
{
    switch (p)
    {
    case placement_t::up:
    case placement_t::up_left:
        return 'P';
    case placement_t::down:
    case placement_t::down_right:
        return 'L';
    case placement_t::left:
    case placement_t::down_left:
        return 'G';
    case placement_t::right:
    case placement_t::up_right:
        return 'D';
    }
    return '\0';
}

char counterclockwise_move(placement_t p)
{
    switch (p)
    {
    case placement_t::up:
    case placement_t::up_right:
        return 'L';
    case placement_t::down:
    case placement_t::down_left:
        return 'P';
    case placement_t::left:
    case placement_t::up_left:
        return 'D';
    case placement_t::right:
    case placement_t::down_right:
        return 'G';
    }
    return '\0';
}

// char clockwise_move(char move)
// {
//     switch (move)
//     {
//     case 'G':
//         return 'P';
//     case 'D':
//         return 'L';
//     case 'L':
//         return 'G';
//     case 'P':
//         return 'D';
//     }
//     return '\0';
// }

// char counterclockwise_move(char move)
// {
//     switch (move)
//     {
//     case 'G':
//         return 'L';
//     case 'D':
//         return 'P';
//     case 'L':
//         return 'D';
//     case 'P':
//         return 'G';
//     }
//     return '\0';
// }

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 << endl;
    }
}

int main()
{
    int n, m, k;
    cin >> n >> m;
    char **board = new char *[n];
    char **board_swap = new char *[n];
    for (int i = 0; i < n; ++i)
    {
        board[i] = new char[m];
        board_swap[i] = new char[m];
        for (int j = 0; j < m; ++j)
        {
            cin >> board[i][j];
        }
    }
    cin >> k;
    char move;
    char first_move, second_move;
    int loopQuarters = 0;

    // char prev_move;

    // determine first move
    cin >> move;
    first_move = move;
    bool hit_corner = false;
    // prev_move = move;
    placement_t placement = from_move_and_placement(move, placement_t::initial);

    for (int i = 1; i < k; ++i)
    {
        cin >> move;
        const auto new_placement = from_move_and_placement(move, placement);

        if (new_placement == placement)
        {
            continue;
        }
        const auto move_type = get_move_type(placement, new_placement);

        // cout << "Move " << static_cast<int>(move_type) << endl;

        if (move_type == move_t::swap)
        {
            first_move = move;
        }
        else
        {
            if (!hit_corner)
            {
                hit_corner = true;
                second_move = move;

                // loopQuarters += move_type;
            }
            else
            {
                loopQuarters += move_type;
            }
        }

        placement = new_placement;
        // prev_move = move;
    }

    // int repetition_period = max(n, m);
    // loopQuarters %= repetition_period * QUARTERS;

    move_by_char<char, '.'>(board, n, m, first_move);

    if (hit_corner)
    {
        move_by_char<char, '.'>(board, n, m, second_move);
        if (loopQuarters != 0)
        {
            auto current_placement = from_move_and_placement(second_move, from_move_and_placement(first_move, placement_t::initial));
            char (*next)(placement_t) = loopQuarters > 0 ? clockwise_move : counterclockwise_move;
            char current_move;
            // print_board(board, n, m);

            int power = abs(loopQuarters) / QUARTERS;
            if (power > 0)
            {

                // create new table filled by pairs of coords O(mn)
                int **intboard = new int *[n];
                for (int i = 0; i < n; ++i)
                {
                    intboard[i] = new int[m];
                    for (int j = 0; j < m; ++j)
                    {
                        intboard[i][j] = board[i][j] == '.' ? -1 : ((i << 16) | j);
                    }
                }

                // make a loop O(mn)

                for (int i = 0; i < 4; ++i)
                {
                    current_move = next(current_placement);
                    current_placement = from_move_and_placement(current_move, current_placement);
                    move_by_char<int, -1>(intboard, n, m, current_move);
                }
                // find destinations O(mn)
                int **dst_board = new int *[n];
                int **dst_board_copy = new int *[n];
                for (int i = 0; i < n; ++i)
                {
                    dst_board[i] = new int[m];
                    dst_board_copy[i] = new int[m];
                }
                for (int i = 0; i < n; ++i)
                {
                    for (int j = 0; j < m; ++j)
                    {
                        if (intboard[i][j] == -1)
                        {
                            dst_board_copy[i][j] = dst_board[i][j] = -1;
                        }
                        else
                        {
                            const int row = intboard[i][j] >> 16,
                                      col = intboard[i][j] & 0xffff;
                            dst_board_copy[row][col] = dst_board[row][col] = ((i << 16) | j);
                        }
                    }
                }
                // "algorytm szybkiego potęgowania" O(mnlogk)

                // cout << "Power " << power << endl;
                int num = 1 << 25;
                while ((power & num) == 0)
                    num >>= 1;
                // cout << "Num " << num << endl;
                num >>= 1;
                while (num > 0)
                {
                    // "square" dst_board using intboard as help space

                    for (int i = 0; i < n; ++i)
                    {
                        for (int j = 0; j < m; ++j)
                        {
                            if (dst_board[i][j] != -1)
                            {
                                const int row = dst_board[i][j] >> 16,
                                          col = dst_board[i][j] & 0xffff;

                                // const int row2 = dst_board[row][col] >> 16,
                                //           col2 = dst_board[row][col] & 0xffff;

                                intboard[i][j] = dst_board[row][col];
                            }
                        }
                    }

                    for (int i = 0; i < n; ++i)
                    {
                        for (int j = 0; j < m; ++j)
                        {
                            dst_board[i][j] = intboard[i][j];
                        }
                    }

                    if (power & num) // non-parite, we have to multiply by single permutation (in dst_board_copy)
                    {
                        for (int i = 0; i < n; ++i)
                        {
                            for (int j = 0; j < m; ++j)
                            {
                                if (dst_board[i][j] != -1)
                                {
                                    const int row = dst_board[i][j] >> 16,
                                              col = dst_board[i][j] & 0xffff;

                                    // const int row2 = dst_board_copy[row][col] >> 16,
                                    //           col2 = dst_board_copy[row][col] & 0xffff;

                                    intboard[i][j] = dst_board_copy[row][col];
                                }
                            }
                        }
                        for (int i = 0; i < n; ++i)
                        {
                            for (int j = 0; j < m; ++j)
                            {
                                dst_board[i][j] = intboard[i][j];
                            }
                        }
                    }
                    num >>= 1;
                }

                // wstawianie literek
                for (int i = 0; i < n; ++i)
                {
                    for (int j = 0; j < m; ++j)
                    {
                        if (dst_board[i][j] == -1)
                        {
                            board_swap[i][j] = '.';
                        }
                        else
                        {
                            const int row = dst_board[i][j] >> 16,
                                      col = dst_board[i][j] & 0xffff;
                            board_swap[row][col] = board[i][j];
                        }
                    }
                }
                for (int i = 0; i < n; ++i)
                {
                    for (int j = 0; j < m; ++j)
                    {
                        board[i][j] = board_swap[i][j];
                    }
                }
            }
            // print_board(board, n, m);
            //  cout << "Quarters " << loopQuarters << endl;

            current_placement = from_move_and_placement(second_move, from_move_and_placement(first_move, placement_t::initial));
            // if (loopQuarters < 0)
            //     loopQuarters = -loopQuarters;
            loopQuarters = abs(loopQuarters) - power * QUARTERS;
            // char current_move;
            for (int i = 0; i < loopQuarters; ++i)
            {
                current_move = next(current_placement);
                current_placement = from_move_and_placement(current_move, current_placement);
                move_by_char<char, '.'>(board, n, m, current_move);
            }
        }
    }

    print_board(board, n, m);

    for (int i = 0; i < n; ++i)
    {
        delete[] board[i];
    }
    delete[] board;
}