#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 piorytet;
};


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 if (tab[parent(i)]->data == tab[i]->data && tab[parent(i)]->piorytet < tab[i]->piorytet)
                {
                        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;
                }*/
                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_elem_max(Node * tab[], int i)
{
        int j = size_h_max;
        int tmp;

        if (i == j)
        {
                size_h_max--;
        }
        else
        {
                swap(tab[i], tab[j]);
                tmp = tab[i]->i_max;
                tab[i]->i_max = tab[j]->i_max;
                tab[j]->i_max = tmp;
                size_h_max--;

                if (i>1 && tab[parent(i)]->data < tab[i]->data)
                {
                        heapify_up_max(tab, i);
                }
                else
                {
                        heapify_max(tab, i, size_h_max);
                }
        }


}


void delete_elem_min(Node * tab[], int i)
{
        int j = size_h_min;
        int tmp;

        if (i == j)
        {
                size_h_min--;
        }
        else
        {
                swap(tab[i], tab[j]);
                tmp = tab[i]->i_min;
                tab[i]->i_min = tab[j]->i_min;
                tab[j]->i_min = tmp;
                size_h_min--;

                if (i > 1 && tab[parent(i)]->data > tab[i]->data)
                {
                        heapify_up_min(tab, i);
                }
                else
                {
                        heapify_min(tab, i, 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;
                }
        }

}

void test(Node * tab_max[], Node * tab_min[], Node tab[], int n)
{
        for (int i = 1; i <= size_h_max; i++)
        {
                cout << tab_max[i]->data << ' ';
        }
        cout << "max" << endl;

        for (int i = 1; i <= size_h_min; 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;
}



int main()
{

        int n, q, c;
        int tmpp;
        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);
                tab[i].piorytet = 6000 - i;
        }

        /*
        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)
                                        {
                                                tmpp = tab_min[1]->i_max;
                                                delete_elem_min(tab_min, 1);
                                                delete_elem_max(tab_max, tmpp);
                                        }
                                        tab_min[1]->data = collatz(tab_min[1]->data);
                                        if (tab_min[1]->data == 1 && size_h_min > 0)
                                        {
                                                tmpp = tab_min[1]->i_max;
                                                delete_elem_min(tab_min, 1);
                                                delete_elem_max(tab_max, tmpp);
                                        }
                                        if (tab_min[1]->data == 0 && size_h_min > 0)
                                        {
                                                tmpp = tab_min[1]->i_max;
                                                delete_elem_min(tab_min, 1);
                                                delete_elem_max(tab_max, tmpp);
                                        }
                                        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)
                                        {
                                                tmpp = tab_max[1]->i_min;
                                                delete_elem_max(tab_max, 1);
                                                delete_elem_min(tab_min, tmpp);
                                        }
                                        if (tab_max[1]->data == 1 && size_h_max > 0)
                                        {
                                                tmpp = tab_max[1]->i_min;
                                                delete_elem_max(tab_max, 1);
                                                delete_elem_min(tab_min, tmpp);
                                        }
                                        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);
                                        }
                                }
                        }
                }
        }






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


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

        }







        return 0;
}