#include<bits/stdc++.h>
using namespace std;

typedef array<array<bool, 5>, 5> Board;   

const pair<int, int> mv[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int MAGIC = 100;
const int maxn = 1e3+5; 
const int INF = 1e9;

struct Piece{
    vector<vector<int>> tiles;
    int height, width;
    int rotation_count;
};

int check_bit(int mask, int i, int j){
    return (mask>>(i*5+j))&1;
}

int set_bit(int &mask, int i, int j){
    int pos = i*5 + j;
    if((mask>>pos)&1)return 0;
    mask^=(1<<pos);
    return 1;
}

map<char, Piece> mp;

Piece rotate(Piece& origin){
    Piece new_piece({
        vector<vector<int>>(origin.width, vector<int>(origin.height)),
        origin.width,
        origin.height,
        origin.rotation_count
    });
    for(int i = 0; i < origin.height; i++){
        for(int j = 0; j < origin.width; j++){
            new_piece.tiles[j][origin.height - i - 1] = origin.tiles[i][j]; 
        }
    }
    return new_piece;
}

int eval(int mask){
    if(mask == -1)return INF;
    return __builtin_popcount(mask);
}

void clear_lines(int& mask){
    int clear_row[5] = {1, 1, 1, 1, 1}, clear_column[5] = {1, 1, 1, 1, 1};
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++)if(!check_bit(mask, i, j)){
            clear_row[i] = 0;
            clear_column[j] = 0;
        }
    }
    for(int i = 0; i < 5; i++){
        for(int j = 0; j < 5; j++){
            if(clear_row[i] || clear_column[j])mask^=(1<<(i*5+j));
        }
    }
}

pair<int, int> try_fit(int mask, int x, int y, Piece& piece){
    for(int i = 0; i < piece.height; i++){
        for(int j = 0; j < piece.width; j++){
            if(!piece.tiles[i][j])continue;
            if(!set_bit(mask, x+i, y+j))return {-1, -1};
        }
    }
    int old_mask = mask;
    clear_lines(mask);
    return {mask, old_mask};
}

pair<int, int> try_all_fit(int mask, Piece& piece){
    pair<int, int> best_mask = {-1, -1};
    for(int i = 0; i < 5 - piece.height + 1; i++){
        for(int j = 0; j < 5 - piece.width + 1; j++){
            auto new_mask = try_fit(mask, i, j, piece);
            if(eval(new_mask.first) < eval(best_mask.first))best_mask = new_mask;
        }
    }
    return best_mask;
}
  
vector<pair<int, pair<int, char>>> dp[maxn];

map<int, pair<int, char>> prv;

bool cmp(pair<int, pair<int, char>> a, pair<int, pair<int, char>> b){
    return eval(a.first) < eval(b.first);
}

int gen_best_move(int mask, int origin, Piece& piece_1, char id){
    pair<int, int> best_mask = {-1, -1};
    for(int i = 0; i < piece_1.rotation_count; i++){
        pair<int, int> new_mask = try_all_fit(mask, piece_1);
        if(eval(new_mask.first) < eval(best_mask.first))best_mask = new_mask;
        piece_1 = rotate(piece_1);
    }
    if(best_mask.first != -1)prv[best_mask.first] = {origin, id};
    return best_mask.second;
}

int main(){

    mp['I'] = Piece({
        {
            {1, 1, 1, 1}
        },
        1,
        4,
        2
    });

    mp['L'] = Piece({
        {
            {1, 0},
            {1, 0},
            {1, 1}
        },
        3,
        2,
        4
    });

    mp['O'] = Piece({
        {
            {1, 1},
            {1, 1}
        },
        2,
        2,
        1
    });

    mp['T'] = Piece({
        {
            {1, 1, 1},
            {0, 1, 0}
        },
        2,
        3,  
        4
    });

    mp['Z'] = Piece({
        {
            {1, 1, 0},
            {0, 1, 1}
        },
        2,
        3,
        2
    });
    string type;
    cin >> type;
    if(type == "prepare"){
        dp[0].push_back({0, {0, 0}});
        int n;
        cin >> n;
        for(int i = 1; i <= n; i++){
            string options;
            cin >> options;
            prv.clear();
            for(int j = 0; j < dp[i-1].size(); j++){
                gen_best_move(dp[i-1][j].first, j, mp[options[0]], options[0]);
                gen_best_move(dp[i-1][j].first, j, mp[options[1]], options[1]);
            }
            for(auto v: prv){
                dp[i].push_back(v);
            }
            sort(dp[i].begin(), dp[i].end(), cmp);
            while(dp[i].size() > MAGIC)dp[i].pop_back();
        }
        string ans(n, 'a');
        int crr = 0;
        for(int i = n; i > 0; i--){
            ans[i-1] = dp[i][crr].second.second;
            crr = dp[i][crr].second.first;
        }
        cout << ans;
    }
    else {
        int n;
        cin >> n;
        int crr = 0;
        for(int i = 1; i <= n; i++){
            char id;
            cin >> id;
            int new_mask = gen_best_move(crr, 0, mp[id], id);
            for(int j = 0; j < 5; j++){
                for(int k = 0; k < 5; k++){
                    if(check_bit(new_mask, j, k)){
                        if(!check_bit(crr, j, k))cout << '*';
                        else cout << '#';
                    }
                    else cout << '.';
                }
                cout << "\n";
            }
            crr = new_mask;
            clear_lines(crr);
            cout << "\n";
        }
    }
}