#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

class Reflektor {
private:
	short int ile_liter;
	short int* permutacja;
public:
	short int get_ile_liter();
	void set_ile_liter(short int a);
	short int* get_permutacja();
	void wczytaj_permutacje();
};

class Wirnik {
private:
	short int ile_liter;
	short int* permutacja_poczatkowa;
	short int ile_obraca;
	short int* litery_obracajace;
	short int* przesuniecia;
	short int obecna_pozycja = 1;
	short int* obecna_permutacja;

public:
	//Wirnik(int ile_lit, int* per, int ile_obr, int* litery_obr);
	~Wirnik();
	short int get_ile_liter();
	void set_ile_liter(short int a);
	short int get_ile_obraca();
	void set_ile_obraca(short int a);
	short int* get_permutacja_poczatkowa();
	short int* get_litery_obracajace();
	void set_permutacja_poczatkowa(short int* elementy);
	void set_litery_obracajace(short int* elementy);
	void wczytaj_permutacje();
	void wyswietl_permutacje();
	void wczytaj_obracajace();
	short int* get_przesuniecia();
	void set_przesuniecia(short int* a);
	short int get_obecna_pozycja();
	void set_obecna_pozycja(short int a);
	void przesun();
	void ustaw_przesuniecia();
	short int szukaj(short int a);
	void ustaw_na_pozycje(short int pozycja);
	void ustaw_aktywna_permutacje(short int* poprzednie);
	void poczatkowa_na_aktywna();
	bool czy_obrocic();
	short int* get_obecna_permutacja();
	void set_obecna_permutacja(short int* a);
	short int* kopiuj_permutacje();
	short int szukaj_p(short int a);
};

/*Wirnik::Wirnik(int ile_lit, int* per, int ile_obr, int* litery_obr) {
	this->ile_liter = ile_lit;
	this->permutacja = per;
	this->ile_obraca = ile_obr;
	this->litery_obracajace = litery_obr;
}*/
Wirnik::~Wirnik() {}
short int Wirnik::get_ile_liter() {
	return ile_liter;
}
short int* Wirnik::get_permutacja_poczatkowa() {
	return permutacja_poczatkowa;
}
short int Wirnik::get_ile_obraca() {
	return ile_obraca;
}
short int* Wirnik::get_litery_obracajace() {
	return litery_obracajace;
}
void Wirnik::set_ile_liter(short int a) {
	this->ile_liter = a;
}
void Wirnik::set_ile_obraca(short int a) {
	this->ile_obraca = a;
}
void Wirnik::set_permutacja_poczatkowa(short int* elementy) {
	this->permutacja_poczatkowa = elementy;
}
void Wirnik::set_litery_obracajace(short int* elementy) {
	this->litery_obracajace = elementy;
}
void Wirnik::wczytaj_permutacje() {
	//this->permutacja_poczatkowa = new int[ile_liter];
	this->permutacja_poczatkowa = (short int*)malloc(ile_liter * sizeof(short int));
	for (int i = 0; i < ile_liter; i++) {
		//cin >> permutacja_poczatkowa[i];
		scanf("%h", &permutacja_poczatkowa[i]);
	}
}
void Wirnik::wyswietl_permutacje() {
	for (int i = 0; i < ile_liter; i++) cout << permutacja_poczatkowa[i];
}
void Wirnik::wczytaj_obracajace() {
	//this->litery_obracajace = new int[ile_obraca];
	this->litery_obracajace = (short int*)malloc(ile_obraca * sizeof(short int));
	for (int i = 0; i < ile_obraca; i++) {
		//cin >> litery_obracajace[i];
		scanf("%h", &litery_obracajace[i]);
	}
}
short int* Wirnik::get_przesuniecia() {
	return przesuniecia;
}
short int Wirnik::get_obecna_pozycja() {
	return obecna_pozycja;
}
void Wirnik::set_obecna_pozycja(short int a) {
	this->obecna_pozycja = a;
}
void Wirnik::set_przesuniecia(short int* a) {
	this->przesuniecia = a;
}
void Wirnik::przesun() {
	short int tmp = this->przesuniecia[0];
	for (int i = 0; i < ile_liter - 1; i++) {
		this->przesuniecia[i] = this->przesuniecia[i + 1];
	}
	this->przesuniecia[ile_liter - 1] = tmp;
	if (obecna_pozycja == ile_liter) obecna_pozycja = 1;
	else obecna_pozycja++;
}
void Wirnik::ustaw_przesuniecia() {
	//this->przesuniecia = new int[ile_liter];
	this->przesuniecia = (short int*)malloc(ile_liter * sizeof(short int));
	for (int i = 0; i < ile_liter; i++) {
		this->przesuniecia[i] = this->szukaj_p(i + 1) - i;
	}
}
short int Wirnik::szukaj(short int a) {
	for (int i = 0; i < ile_liter; i++) {
		if (obecna_permutacja[i] == a) return i;
	}
	return -1;
}
short int Wirnik::szukaj_p(short int a) {
	for (int i = 0; i< ile_liter; i++)
		if (permutacja_poczatkowa[i] == a) return i;
	return -1;
}
void Wirnik::ustaw_na_pozycje(short int pozycja) {
	while (this->obecna_pozycja != pozycja) this->przesun();
}
void Wirnik::ustaw_aktywna_permutacje(short int* poprzednie) {
	for (int i = 0; i < ile_liter; i++) {
		if (przesuniecia[i] + i < 0) przesuniecia[i] = ile_liter + przesuniecia[i];
		else if (przesuniecia[i] + i > ile_liter - 1) przesuniecia[i] = przesuniecia[i] - ile_liter;
		this->obecna_permutacja[i] = poprzednie[i + przesuniecia[i]];
	}
}
void Wirnik::poczatkowa_na_aktywna() {
	//this->obecna_permutacja = new int[ile_liter];
	this->obecna_permutacja = (short int*)malloc(ile_liter * sizeof(int));
	for (int i = 0; i < ile_liter; i++) {
		obecna_permutacja[i] = permutacja_poczatkowa[i];
	}
}
bool Wirnik::czy_obrocic() {
	for (int i = 0; i < ile_obraca; i++) {
		if (obecna_pozycja == litery_obracajace[i]) return true;
	}
	return false;
}
short int* Wirnik::get_obecna_permutacja() {
	return obecna_permutacja;
}
void Wirnik::set_obecna_permutacja(short int* a) {
	this->obecna_permutacja = a;
}
short int* Wirnik::kopiuj_permutacje() {
	//int* nowy = new int[ile_liter];
	short int* nowy = (short int*)malloc(ile_liter * sizeof(short int));
	for (int i = 0; i < ile_liter; i++) {
		nowy[i] = this->obecna_permutacja[i];
	}
	return nowy;
}


short int Reflektor::get_ile_liter() {
	return ile_liter;
}
short int* Reflektor::get_permutacja() {
	return permutacja;
}
void Reflektor::set_ile_liter(short int a) {
	this->ile_liter = a;
}
void Reflektor::wczytaj_permutacje() {
	//this->permutacja = new int[ile_liter];
	this->permutacja = (short int*)malloc(ile_liter * sizeof(short int));
	for (int i = 0; i < ile_liter; i++) {
		//cin >> this->permutacja[i];
		scanf("%h", &permutacja[i]);
	}
}



int main()
{
	//ios::sync_with_stdio(false);
	short int ile_liter = 0;
	//cin >> ile_liter;
	scanf("%h", &ile_liter);
	//int* podstawa = new int[ile_liter];
	short int* podstawa = (short int*)malloc(ile_liter * sizeof(short int));
	for (int i = 1; i <= ile_liter; i++) podstawa[i - 1] = i;
	short int ile_wirnikow = 0;
	//cin >> ile_wirnikow;
	scanf("%h", &ile_wirnikow);
	Wirnik* wirniki = new Wirnik[ile_wirnikow];
	for (int i = 0; i < ile_wirnikow; i++) {
		wirniki[i].set_ile_liter(ile_liter);
		wirniki[i].wczytaj_permutacje();
		short int ile_obraca;
		//cin >> ile_obraca;
		scanf("%h", &ile_obraca);
		wirniki[i].set_ile_obraca(ile_obraca);
		wirniki[i].wczytaj_obracajace();
		//cout << endl;
		//wirniki[i].wyswietl_permutacje();
		//cout << endl << endl;
	}
	short int liczba_reflektorow;
	//cin >> liczba_reflektorow;
	scanf("%h", &liczba_reflektorow);
	Reflektor* reflektory = new Reflektor[liczba_reflektorow];
	for (int i = 0; i < liczba_reflektorow; i++) {
		reflektory[i].set_ile_liter(ile_liter);
		reflektory[i].wczytaj_permutacje();
		//cout << endl;
		//reflektory[i].wyswietl_permutacje();
		//cout << endl << endl;
	}

	short int liczba_zadan;
	//cin >> liczba_zadan;
	scanf("%h", &liczba_zadan);
	for (int i = 0; i < liczba_zadan; i++) {
		short int ile_aktywnych_wirnikow;
		//cin >> ile_aktywnych_wirnikow;
		scanf("%h", &ile_aktywnych_wirnikow);
		Wirnik* aktywne_wirniki = new Wirnik[ile_aktywnych_wirnikow];
		for (int j = 0; j < ile_aktywnych_wirnikow; j++) {
			short int indeks_wirnika;
			//cin >> indeks_wirnika;
			scanf("%h", &indeks_wirnika);
			aktywne_wirniki[j] = wirniki[indeks_wirnika];
			short int pozycja_poczatkowa;
			//cin >> pozycja_poczatkowa;
			scanf("%h", &pozycja_poczatkowa);
			aktywne_wirniki[j].ustaw_przesuniecia();
			aktywne_wirniki[j].poczatkowa_na_aktywna();
			aktywne_wirniki[j].ustaw_na_pozycje(pozycja_poczatkowa);
		}
		short int indeks_reflektora;
		//cin >> indeks_reflektora;
		scanf("%h", &indeks_reflektora);
		Reflektor aktywny_reflektor = reflektory[indeks_reflektora];
		bool odwrocony_2 = false;
		for (int x = 0;; x++) {
			short int oryginal;

			//cin >> oryginal;
			scanf("%h", &oryginal);
			if (oryginal == 0) break;
			else {
				aktywne_wirniki[0].przesun();
				aktywne_wirniki[0].ustaw_aktywna_permutacje(podstawa);

				for (int j = 1; j < ile_aktywnych_wirnikow; j++) {
					if (x != 0 && j == 1 && aktywne_wirniki[j - 1].czy_obrocic()) {
						aktywne_wirniki[j].przesun();
						odwrocony_2 = true;
						aktywne_wirniki[j].ustaw_aktywna_permutacje(aktywne_wirniki[j - 1].get_obecna_permutacja());
						continue;
					}
					else if (x != 0 && j == 2 && odwrocony_2 && aktywne_wirniki[j - 1].czy_obrocic()) {
						aktywne_wirniki[j].przesun();
						aktywne_wirniki[j - 1].przesun();
						aktywne_wirniki[j - 1].ustaw_aktywna_permutacje(aktywne_wirniki[j - 2].get_obecna_permutacja());
					}
					//int* poprzednie = aktywne_wirniki[j-1].kopiuj_permutacje();
					aktywne_wirniki[j].ustaw_aktywna_permutacje(aktywne_wirniki[j - 1].get_obecna_permutacja());
				}
				//int indeks = aktywne_wirniki[ile_aktywnych_wirnikow - 1].szukaj(oryginal);
				//int* permutacje_reflektora = aktywny_reflektor.get_permutacja_poczatkowa();
				//int indeks_w_reflektorze = permutacje_reflektora[indeks]-1;
				//int* ostatni_wirnik = aktywne_wirniki[ile_aktywnych_wirnikow -1].get_obecna_permutacja();
				//cout << aktywne_wirniki[ile_aktywnych_wirnikow - 1].get_obecna_permutacja()[aktywny_reflektor.get_permutacja_poczatkowa()[aktywne_wirniki[ile_aktywnych_wirnikow - 1].szukaj(oryginal)] - 1] << '\n';
				printf("%d",aktywne_wirniki[ile_aktywnych_wirnikow - 1].get_obecna_permutacja()[aktywny_reflektor.get_permutacja()[aktywne_wirniki[ile_aktywnych_wirnikow - 1].szukaj(oryginal)] - 1]);
				printf("%c", '\n');

			}
		}
	}

	return 0;
}