#include <iostream>
#include <algorithm>


using namespace std;


int size_h_max = 0;
int size_h_min = 0;

struct Node
{
    unsigned int data;
    int i_max;
    int i_min;
};


int parent(int i)
{
    return i / 2;
}

int left(int i)
{
    return i * 2;
}

int right(int i)
{
    return i * 2 + 1;
}

void heap_push_max(Node * tab[], unsigned int elem)
{
    int i = size_h_max + 1;
    tab[i]->data = elem;
    int tmp;
    tab[i]->i_max = i;

    while (i>1)
    {
        if (tab[parent(i)]->data > tab[i]->data)
        {
            break;
        }
        else
        {
            swap(tab[parent(i)], tab[i]);
            tmp = tab[parent(i)]->i_max;
            tab[parent(i)]->i_max = tab[i]->i_max;
            tab[i]->i_max = tmp;

            i /= 2;
        }
    }
    size_h_max++;
}



void heap_push_min(Node * tab[], unsigned int elem)
{
    int i = size_h_min + 1;
    tab[i]->data = elem;
    int tmp;
    tab[i]->i_min = i;

    while (i>1)
    {
        if (tab[parent(i)]->data < tab[i]->data)
        {
            break;
        }
        else
        {
            swap(tab[parent(i)], tab[i]);
            tmp = tab[parent(i)]->i_min;
            tab[parent(i)]->i_min = tab[i]->i_min;
            tab[i]->i_min = tmp;

            i /= 2;
        }
    }
    size_h_min++;
}

void heapify_max(Node * tab[], int i, int size)
{
    int tmp;

    int L = left(i);
    int R = right(i);
    int maxps;

    if (L <= size && tab[L]->data > tab[i]->data)
    {
        maxps = L;
    }
    else
    {
        maxps = i;
    }

    if (R <= size && tab[R]->data > tab[maxps]->data)
    {
        maxps = R;
    }
    if (maxps != i)
    {
        swap(tab[i], tab[maxps]);
        tmp = tab[i]->i_max;
        tab[i]->i_max = tab[maxps]->i_max;
        tab[maxps]->i_max = tmp;
        heapify_max(tab, maxps, size);
    }
}

void heapify_up_max(Node * tab[], int i)
{
    int tmp;
    while (i > 1)
    {
        if (tab[parent(i)]->data < tab[i]->data)
            {
                swap(tab[i], tab[parent(i)]);
                tmp = tab[i]->i_max;
                tab[i]->i_max = tab[parent(i)]->i_max;
                tab[parent(i)]->i_max = tmp;
                i /= 2;
                heapify_up_max(tab, i);
            }
        else
        {
            break;
        }
    }

}

void heapify_up_min(Node * tab[], int i)
{
    int tmp;
    while (i > 1)
    {
        if (tab[parent(i)]->data > tab[i]->data)
        {
            swap(tab[i], tab[parent(i)]);
            tmp = tab[i]->i_min;
            tab[i]->i_min = tab[parent(i)]->i_min;
            tab[parent(i)]->i_min = tmp;
            i /= 2;
            heapify_up_min(tab, i);
        }
        else
        {
            break;
        }
    }

}

void heapify_min(Node * tab[], int i, int size)
{
    int tmp;

    int L = left(i);
    int R = right(i);
    int maxps;

    if (L <= size && tab[L]->data < tab[i]->data && tab[L]->data > 0)
    {
        maxps = L;
    }
    else
    {
        maxps = i;
    }

    if (R <= size && tab[R]->data < tab[maxps]->data && tab[R]->data > 0)
    {
        maxps = R;
    }
    if (maxps != i)
    {
        swap(tab[i], tab[maxps]);
        tmp = tab[i]->i_min;
        tab[i]->i_min = tab[maxps]->i_min;
        tab[maxps]->i_min = tmp;
        heapify_min(tab, maxps, size);
    }
}



void delete_root_max(Node * tab[])
{
    int j = size_h_max;
    int tmp;

    swap(tab[1], tab[j]);
    tmp = tab[1]->i_max;
    tab[1]->i_max = tab[j]->i_max;
    tab[j]->i_max = tmp;
    size_h_max--;
    heapify_max(tab, 1, size_h_max);
}

void delete_root_min(Node * tab[])
{
    int j = size_h_min;
    int tmp;

    swap(tab[1], tab[j]);
    tmp = tab[1]->i_min;
    tab[1]->i_min = tab[j]->i_min;
    tab[j]->i_min = tmp;
    size_h_min--;
    heapify_min(tab, 1, size_h_min);
}





long long int collatz(unsigned int n)
{
    unsigned int m;
    m = n;

    if (n % 2 == 0)
    {
        return n / 2;
    }
    else
    {
        n = 3 * n + 1;
        if ((n-1)/3 != m)
        {
            return 0;
        }
        else
        {
            return n;
        }
    }

}



int main()
{

    int n, q, c;
    unsigned int tmp;
    char temp;

    cin >> n;
    Node **tab_min = new Node *[n+1];
    Node **tab_max = new Node *[n+1];
    Node *tab = new Node[n+1];


    for (int i = 1; i <= n; i++)
    {
        cin >> tmp;
        tab_max[i] = &(tab[i]);
        heap_push_max(tab_max, tmp);
        tab_min[i] = &(tab[i]);
        heap_push_min(tab_min, tmp);
    }

    /*
    for (int i = 1; i <= size_h_max; i++)
    {
        cout << tab_max[i]->data << ' ';
    }
    cout << "max" << endl;

    for (int i = 1; i <= size_h_max; i++)
    {
        cout << tab_min[i]->data << ' ';
    }
    cout << "min" << endl;

    for (int i = 1; i <= n; i++)
    {
        if (tab[i].data == 0)
        {
            cout << 'm' << ' ';
        }
        else
        {
            cout << tab[i].data << ' ';
        }
    }
    cout << "str" << endl;
    cout << "*******************************" << endl;

*/




    cin >> q;


    for (int i = 0; i < q; i++)
    {
        cin >> c;
        cin >> temp;

        if (temp == 's')
        {
            for (int i = 0; i < c; i++)
            {
                if (size_h_min > 0)
                {
                    while (tab_min[1]->data == 1 && size_h_min > 0)
                    {
                        delete_root_min(tab_min);
                    }
                    tab_min[1]->data = collatz(tab_min[1]->data);
                    if (tab_min[1]->data == 0 && size_h_min > 0)
                    {
                        delete_root_min(tab_min);
                    }
                    else if (size_h_min > 0)
                    {
                        heapify_up_max(tab_max, tab_min[1]->i_max);
                        heapify_max(tab_max, tab_min[1]->i_max, size_h_max);
                        heapify_min(tab_min, 1, size_h_min);
                    }
                }
            }
        }
        else if (temp == 'l')
        {
            for (int i = 0; i < c; i++)
            {
                if (size_h_max > 0 && tab_max[1]->data != 1)
                {
                    tab_max[1]->data = collatz(tab_max[1]->data);
                    if (tab_max[1]->data == 0 && size_h_max > 0)
                    {
                        delete_root_max(tab_max);
                    }
                    else if (size_h_max > 0)
                    {
                        heapify_up_min(tab_min, tab_max[1]->i_min);
                        heapify_min(tab_min, tab_max[1]->i_min, size_h_min);
                        heapify_max(tab_max, 1, size_h_max);
                    }
                    if (tab_min[1] == 0 && size_h_min > 0)
                    {
                        delete_root_min(tab_min);
                    }
                }
            }


        }
    }






    for (int i = 1; i <= n; i++)
    {


        if (tab[i].data == 0)
        {
            cout << 'm' << ' ';
        }
        else
        {
            cout << tab[i].data << ' ';
        }

    }







    return 0;
}