#include <iostream>
#include <string>

using namespace std;

struct stempel
{
    string name;
    int number;
};

struct xy
{
    int x;
    int y;
};

class List
{
    class part
    {
    public:
        stempel value;
        part *next;
        part *previus;
    };
public:
    part *head;
    part *tail;
    part *pos;
    int counter = 0;

    List();
    void push_back(stempel);
    void search(int);
    void erase();
};

List::List()
{
    head = nullptr;
    tail = nullptr;
    pos = nullptr;
}

void List::push_back(stempel s)
{
    part *frag = new part;
    frag->next = nullptr;
    frag->previus = nullptr;
    frag->value = s;

    if (head == nullptr)
    {
        frag->next = frag;
        frag->previus = frag;
        head = frag;
        tail = frag;
        pos = head;
        counter++;
    }
    else
    {
        frag->next = head;
        head->previus = frag;
        frag->previus = tail;
        tail->next = frag;
        tail = frag;
        counter++;
    }
}

void List::search(int y)
{
    if (pos == nullptr) pos = head;
    if (y == 0) return;

    if (y > 0)
    {
        y = y%counter;
        for (int i = 1; i <= y; i++)
        {
            pos = pos->next;
        }
    }
    else
    {
        y = y*(-1);
        y = y%counter;
        for (int i = 1; i <= y; i++)
        {
            pos = pos->previus;
        }
    }
}

void List::erase()
{
    if (head == nullptr) return;

    part *temp = head;

    if (pos == head && pos == tail)
    {
        head = nullptr;
        tail = nullptr;
        pos = nullptr;
        delete temp;
        return;
    }

    if (pos == head)
    {
        head = temp->next;
        head->previus = temp->previus;
        temp->previus->next = head;
        delete temp;
        pos = head;
    }
    else if (pos == tail)
    {
        temp = tail->previus;
        temp->next = head;
        head->previus = temp;
        delete tail;
        tail = temp;
        pos = head;
    }
    else
    {
        part *postemp = pos->next;
        temp = pos->previus;
        temp->next = pos->next;
        pos->next->previus = temp;
        delete pos;
        pos = postemp;
    }
    counter--;
}

class List_main
{
    class part
    {
    public:
        List *value;
        part *next;
        part *previus;
    };
public:
    part *head;
    part *tail;
    part *pos;
    int sum;
    int counter = 0;
    int oldval = 0;

    List_main();
    void search(int, int);
    void push_back(List*);
    void count_sum();
    void erase();
    void show() const;
    bool isempty();
};

List_main::List_main()
{
    head = nullptr;
    tail = nullptr;
    pos = nullptr;
}

void List_main::show() const
{
    part *temp = head;
    while (temp->next != head)
    {
        cout << temp->value->pos->value.name;
        temp = temp->next;
    }
    cout << temp->value->pos->value.name;
}

void List_main::push_back(List* l)
{
    part *frag = new part;
    frag->next = nullptr;
    frag->previus = nullptr;
    frag->value = l;

    if (head == nullptr)
    {
        frag->next = frag;
        frag->previus = frag;
        head = frag;
        tail = frag;
        pos = head;
        counter++;
    }
    else
    {
        frag->next = head;
        head->previus = frag;
        frag->previus = tail;
        tail->next = frag;
        tail = frag;
        counter++;
    }
}

void List_main::search(int x, int y)
{
    if (pos == nullptr) pos = head;

        if (x == 0)
        {
            sum -= pos->value->pos->value.number;
            pos->value->search(y);
            sum += pos->value->pos->value.number;
            return;
        }

        if (x > 0)
        {
            x = x%counter;
            for (int i = 1; i <= x; i++)
            {
                pos = pos->next;
            }
            sum -= pos->value->pos->value.number;
        }
        else
        {
            x = x*(-1);
            x = x%counter;
            for (int i = 1; i <= x; i++)
            {
                pos = pos->previus;
            }
            sum -= pos->value->pos->value.number;
        }

    pos->value->search(y);
    sum += pos->value->pos->value.number;
}

void List_main::count_sum()
{
    part *temp = head;
    sum = 0;
    while (temp->next != head)
    {
        sum += temp->value->pos->value.number;
        temp = temp->next;
    }
    sum += temp->value->pos->value.number;
}

void List_main::erase()
{
    if (head == nullptr) return;

    part *temp = head;
    sum = 0;

    while (temp->next != head)
    {
        temp->value->erase();
        if (temp->value->head == nullptr && counter>1)
        {
            part *temp2 = temp->previus;
            if (temp == head && counter!=1)
            {
                int s = 0;
                temp2 = head->previus;
                head = head->next;
                temp2->next = head;
                head->previus = temp2;
                counter--;
            }
            else
            {
                part* tempnext = temp->next;
                temp2->next = tempnext;
                tempnext->previus = temp2;
                counter--;
            }
        }
        else sum += temp->value->pos->value.number;

        temp = temp->next;
    }
    temp->value->erase();
    if (temp->value->head == nullptr)
    {
        part *temp2 = temp->previus;
        temp2->next = head;
        head->previus = temp2;
        delete temp;
        counter--;
    }
    else
    {
        sum += temp->value->pos->value.number;
    }
    if (counter == 1) sum = this->head->value->pos->value.number;
}

bool List_main::isempty()
{
    if (counter == 0) return true;
    else return false;
}

class SumList
{
    class part
    {
    public:
        int value;
        part *next;
    };
public:
    part *head;
    part *tail;

    SumList()
    {
        head = nullptr;
        tail = nullptr;
    }

    void push_back(int val)
    {
        part *frag = new part;
        frag->value = val;
        frag->next = nullptr;

        if (head == nullptr)
        {
            head = frag;
            tail = frag;
            return;
        }
        else
        {
            tail->next = frag;
            tail = tail->next;
        }
    }

    bool isempty()
    {
        if (head == nullptr) return true;
        else return false;
    }

    bool searchAndRemove(int val)
    {
        if (head != nullptr)
        {
            part* temp = head;
            if (head->value == val)
            {
                head = head->next;
                delete temp;
                return true;
            }
            else
            {
                while (temp->next != nullptr && temp->next->value != val)
                {
                    temp = temp->next;
                }

                if (temp->next == nullptr) return false;
                else
                {
                    if (temp->next->value == val)
                    {
                        part* remove = temp->next;
                        temp->next = temp->next->next;
                        delete remove;
                        return true;
                    }
                }
            }
        }
        else
            return false;
        return false;
    }
};

int main()
{
    ios_base::sync_with_stdio(false);

    int n;
    cin >> n;

    stempel s;
    List_main lm;
    int m;

    for (int i = 0; i < n; i++)
    {
        List *li = new List;
        cin >> m;
        for (int j = 1; j <= m; j++)
        {
            cin >> s.name >> s.number;
            li->push_back(s);

        }
        lm.push_back(li);
    }

    int l;
    cin >> l;

    SumList sums;
    for (int i = 0; i < l; i++)
    {
        int s;
        cin >> s;
        sums.push_back(s);
    }

    int h;
    cin >> h;

    xy *tabxy = new xy[h];

    for (int i = 0; i < h; i++)
    {
        cin >> tabxy[i].x >> tabxy[i].y;
    }

    int newl = l;
    bool findsum = false;
    int movecounter = 0;
    bool sumMoving = false;

    lm.count_sum();

    //======
    while (true)
    {
        findsum = true;
        sumMoving = true;

        if (findsum)
        {
            if (!lm.isempty() && sums.searchAndRemove(lm.sum))
            {
                cout << lm.sum << " ";
                lm.show();
                cout << endl;
                lm.erase();
                findsum = true;
            }
            else findsum = false;
        }
        if (!findsum && !lm.isempty() && movecounter < h)
        {
            lm.search(tabxy[movecounter].x, tabxy[movecounter].y);
            movecounter++;
            if (!lm.isempty() && sums.searchAndRemove(lm.sum))
            {
                cout << lm.sum << " ";
                lm.show();
                cout << endl;
                lm.erase();
                sumMoving = true;
            }
            else sumMoving = false;
        }
        else sumMoving = false;

        if (lm.isempty()) break;
        if (!sumMoving && !findsum && movecounter >= h) break;
        if (sums.isempty()) break;
    }

    delete[] tabxy;
    return 0;
}