#include <iostream>

using namespace std;

class Lista {
private:
	typedef struct element {
		string slowo;
		int wartosc;
		element* nastepny;
		element* poprzedni;

	}element;
	element* pozycja_pierwszego;
	element* pozycja_ost;

	int size;
	int ile;
public:
	Lista();
	element* aktualny;
	~Lista();
	void insert(string, int, int);
	void erase(element*);
	void push_front(string, int);
	void push_back(string, int);
	int get_size();
	void przesuniecie(int);
	void aktualnie(int);
	element* akt();


};

int main()
{
	string slowo;
	int wartosc;
	Lista list;
	int rozmiar_listy;
	int indeks_pierwszego;
	cin >> rozmiar_listy >> indeks_pierwszego;
	for (int i = 0; i < rozmiar_listy; i++)
	{
		cin >> slowo >> wartosc;
		list.push_back(slowo, wartosc);
	}
	list.aktualnie(indeks_pierwszego);

	//    list.display_test();
	//    list.erase(&indeks_pierwszego);
	//    list.display_test();
	int rozmiar_drugiej;
	cin >> rozmiar_drugiej;
	while (list.get_size() > 0)
	{
		if (list.akt()->wartosc == 0)
		{
			int war;
			cin >> slowo >> wartosc >> war;
			list.insert(slowo, wartosc, war);
			list.przesuniecie(war);
		}
		else
		{
			//wyswietlamy slowo
			cout << list.akt()->slowo << " ";
			//jezeli jest dodatni idziemy o krok do przodu,
			if (list.akt()->wartosc > 0)
			{
				int wart = list.aktualny->wartosc;
				list.aktualny = list.aktualny->nastepny;
				list.erase(list.aktualny->poprzedni);
				list.przesuniecie(wart - 1);
			}
			//jezeli ujemny to do tylu
			else
			{
				int wart = list.aktualny->wartosc;
				list.aktualny = list.aktualny->poprzedni;
				list.erase(list.aktualny->nastepny);
				list.przesuniecie(wart + 1);
			}




			//list.erase(list.akt());

		}
	}
	return 0;
}
Lista::Lista()
{
	pozycja_pierwszego = pozycja_ost = nullptr;
	size = 0;
}

Lista::~Lista()
{

}
void Lista::insert(string slowo, int wartosc, int war)
{
	element* el = aktualny;
	element* nowy = new element;
	nowy->slowo = slowo;
	nowy->wartosc = wartosc;
	el->poprzedni->nastepny = nowy;
	nowy->poprzedni = el->poprzedni;
	el->wartosc = war;
	nowy->nastepny = el;
	el->poprzedni = nowy;
	size++;
	if (this->aktualny == this->pozycja_pierwszego)
		this->pozycja_pierwszego = aktualny->poprzedni;


}

void Lista::erase(element* el)   //to tak naprawde nie jest indeks pierwszego xDD
{
	int war = this->aktualny->wartosc;
	el->poprzedni->nastepny = el->nastepny;
	el->nastepny->poprzedni = el->poprzedni;
	if (el == pozycja_ost)
		pozycja_ost = el->poprzedni;
	if (el == pozycja_pierwszego)
		pozycja_pierwszego = el->nastepny;
	if (this->size == 1)
	{
		pozycja_pierwszego = pozycja_ost = NULL;
		size = 0;
		delete el;
		return;
	}
	size--;
	delete el;


}
void Lista::push_front(string slowo, int wartosc)
{
	element* pomocniczy = new element;
	pomocniczy->slowo = slowo;
	pomocniczy->wartosc = wartosc;
	pomocniczy->poprzedni = pomocniczy;
	pomocniczy->nastepny = pomocniczy;
	pozycja_pierwszego = pomocniczy;
	pozycja_ost = pomocniczy;
	aktualny = pozycja_pierwszego;
}

void Lista::push_back(string slowo, int wartosc)
{
	if (pozycja_pierwszego == nullptr)
		push_front(slowo, wartosc);
	else
	{
		element* nowy = new element;
		nowy->slowo = slowo;
		nowy->wartosc = wartosc;
		nowy->nastepny = pozycja_pierwszego;
		nowy->poprzedni = pozycja_ost;
		pozycja_ost->nastepny = nowy;
		pozycja_pierwszego->poprzedni = nowy;
		pozycja_ost = nowy;
	}
	size++;
}

int Lista::get_size()
{
	return size;
}
void Lista::przesuniecie(int ile)
{
	if (size > 0)
	{
		if (ile > 0 && size > 0)
			ile = ile % size;

		if (ile > 0)
		{
			for (int i = 0; i < ile; i++)
				aktualny = aktualny->nastepny;

		}
		if (ile < 0)
		{

			for (int i = 0; i < std::abs(ile); i++)
				aktualny = aktualny->poprzedni;

		}

	}
}
/*void Lista::przesuniecie(int ile)
{
	ile = ile%size;
	if(size == 2)
	{
		aktualny = aktualny->nastepny;
		return;
	}
//    if(size < 2)
//        return;
	float polowa = (float)(size)/2;
	if(ile < 0)
	{
		if(ile*-1>= polowa)
		{
		for(int i = (size + ile);i>0;i--)
			{

			aktualny = aktualny->nastepny;
			}
		}
		else
			for(int i = 0; i < ile*-1; i++)
				aktualny = aktualny->poprzedni;
	}
	 else if(ile > 0)
		{
			if(ile >= polowa)
			{
			for(int i = (size +ile)%size;i>0;i--)
				{

				aktualny = aktualny->poprzedni;
				}
			}
			else
				for(int i = 0; i < ile; i++)
					aktualny = aktualny->nastepny;

	}

}
*/
void Lista::aktualnie(int indeks)
{

	element* el = aktualny;
	for (int i = 0; i < indeks; i++)
		el = el->nastepny;
	aktualny = el;
}

Lista::element* Lista::akt()
{
	return aktualny;
}