#include <stdio.h>
#include <stdlib.h>


void przesun_wirnik_do_pozycji(int* array1, int* array2, int position, int array_size) {
    int temp1 = 0;
    int temp2 = 0;
    for (int i = 0; i < position - 1; i++) {
        temp1 = array1[0];
        temp2 = array2[0];
        for (int j = 0; j < array_size; j++) {
            array1[j] = array1[j + 1];
            array2[j] = array2[j + 1];
        }
        array1[array_size - 1] = temp1;
        array2[array_size - 1] = temp2;
    }
}

int znajdz_index(int* array, int* index, int znajdz, int size) {
    for (int i = 0; i < size; i++) {
        if (array[i] == znajdz) {
            *index = i;
            break;
        }
    }
    return *index;
}

int main() {
    //alfabet
    int alfabet;
    scanf("%d", &alfabet);
    //tablica alfabetu
    int* ile_alfabet = (int*)calloc(alfabet, sizeof(int));
    int* ile_alfabet_dla_wirnika = (int*)calloc(alfabet, sizeof(int));
    for (int i = 0; i < alfabet; i++) {
        ile_alfabet[i] = i + 1;
        ile_alfabet_dla_wirnika[i] = i + 1;
    }
    //wirniki_w_maszynie
    int ile_wirnikow_w_maszynie;
    scanf("%d", &ile_wirnikow_w_maszynie);

    //deklaracja tablicy na wirniki_w_maszynie
    int** wirniki_w_maszynie = (int**)calloc(ile_wirnikow_w_maszynie, sizeof(*wirniki_w_maszynie));
    for (int i = 0; i < ile_wirnikow_w_maszynie; i++) {
        wirniki_w_maszynie[i] = (int*)calloc(alfabet, sizeof(wirniki_w_maszynie[0]));
    }
    //deklaracja tablicy na notche
    int** wirniki_w_maszynie_notche = (int**)calloc(ile_wirnikow_w_maszynie,sizeof(*wirniki_w_maszynie_notche));
    for (int i = 0; i < ile_wirnikow_w_maszynie; i++) {
        wirniki_w_maszynie_notche[i] = (int*)calloc(alfabet,sizeof(wirniki_w_maszynie_notche[0]));
    }

    //wczytywanie wirników
    for (int i = 0; i < ile_wirnikow_w_maszynie; i++) {
        //wirnik
        for (int j = 0; j < alfabet; j++) {
            scanf("%d", &wirniki_w_maszynie[i][j]);
        }
        //notche
        int notche;
        scanf("%d", &notche);
        if (notche != 0) {
            for (int j = 0; j < notche; j++) {
                int notch;
                scanf("%d", &notch);
                wirniki_w_maszynie_notche[i][notch - 1] = 1;
            }
        }
    }

    //reflektory_w_maszynie
    int ile_reflektorow;
    scanf("%d", &ile_reflektorow);

    //deklaracja tablicy na wirniki_w_maszynie
    int** reflektory_w_maszynie = (int**)calloc(ile_reflektorow, sizeof(*reflektory_w_maszynie));
    for (int i = 0; i < ile_reflektorow; i++) {
        reflektory_w_maszynie[i] = (int*)calloc(alfabet, sizeof(reflektory_w_maszynie[0]));
    }
    //wczytywanie wirników
    for (int i = 0; i < ile_reflektorow; i++) {
        for (int j = 0; j < alfabet; j++) {
            scanf("%d", &reflektory_w_maszynie[i][j]);
        }
    }

    int zadania;
    scanf("%d", &zadania);
    for (int a = 0; a < zadania; a++) {
        //trzeba zrobic tablice wirnikow dla zadania
        int ile_wirnikow_koduje;
        scanf("%d", &ile_wirnikow_koduje);
        int* ustawienia_zadan = (int*)calloc((ile_wirnikow_koduje * 2) + 1, sizeof(int));
        for (int i = 0; i < (ile_wirnikow_koduje * 2) + 1; i++) {
            scanf("%d", &ustawienia_zadan[i]);
        }
        //i wybrac reflektor do zadania
        int* wybrany_reflektor = (int*)calloc(alfabet, sizeof(int));
        int ktory_reflektor = ustawienia_zadan[(ile_wirnikow_koduje * 2)];
        for (int i = 0; i < alfabet; i++) {
            wybrany_reflektor[i] = reflektory_w_maszynie[ktory_reflektor][i];
        }

        switch (ile_wirnikow_koduje) {
            case 1: {
                for (int i = 0; i < alfabet; i++) {
                    ile_alfabet_dla_wirnika[i] = i + 1;
                }
                int* tablica_wirnikow = (int*)calloc(alfabet, sizeof(int));
                int ktory_wirnik = ustawienia_zadan[(ile_wirnikow_koduje - 1)];
                for (int i = 0; i < ile_wirnikow_koduje; i++) {
                    for (int j = 0; j < alfabet; j++) {
                        tablica_wirnikow[j] = wirniki_w_maszynie[ktory_wirnik][j];
                    }
                }
                //odpowiednio je przesunac - zmiana
                if (ustawienia_zadan[1]%alfabet!=0) {
                    przesun_wirnik_do_pozycji(tablica_wirnikow,ile_alfabet_dla_wirnika, ustawienia_zadan[1], alfabet);
                    przesun_wirnik_do_pozycji(tablica_wirnikow, ile_alfabet_dla_wirnika, 2, alfabet);
                }


                //i potem kodowac po kolei litery
                int input;
                scanf("%d", &input);
                int index = 0;
                while (input != 0) {
                    //szyfrowanie - kodowanie liter
                    //1.wchodzi liczba - znajduje jej indeks w alfabecie
                    input = tablica_wirnikow[input-1];
                    //2.szukam indeksu w alfabecie wirnika z tą liczbą
                    znajdz_index(ile_alfabet_dla_wirnika, &index, input, alfabet);
                    input = wybrany_reflektor[index];
                    //3.szukam w alfabecie index z tą wartością
                    znajdz_index(ile_alfabet, &index, input, alfabet);
                    input = ile_alfabet_dla_wirnika[index];
                    //4.szukam indexu wirnika z ta wartoscią
                    znajdz_index(tablica_wirnikow, &index, input, alfabet);
                    input = ile_alfabet[index];

                    printf("%d", input);
                    printf(" ");
                    przesun_wirnik_do_pozycji(tablica_wirnikow, ile_alfabet_dla_wirnika, 2, alfabet);
                    scanf("%d", &input);
                }
                printf("\n");
                //in ilosc wirnikow
                //in numer wirnika i ustawienie parami tyle razy ile wirnikow
                //in numer reflektora
                //in literka
                //zwalnianie pamieci
                free(tablica_wirnikow);
                break;
            }

            case 2: {
                int* tablica_wirnikow1 = (int*)calloc(alfabet, sizeof(int));
                int* tablica_wirnikow2 = (int*)calloc(alfabet, sizeof(int));
                int ktory_wirnik1 = ustawienia_zadan[0];
                int ktory_wirnik2 = ustawienia_zadan[2];
                for (int i = 0; i < alfabet; i++) {
                    tablica_wirnikow1[i] = wirniki_w_maszynie[ktory_wirnik1][i];
                    tablica_wirnikow2[i] = wirniki_w_maszynie[ktory_wirnik2][i];
                }
                int* ile_alfabet_dla_wirnika1 = (int*)calloc(alfabet, sizeof(int));
                for (int i = 0; i < alfabet; i++) {
                    ile_alfabet_dla_wirnika[i] = i + 1;
                    ile_alfabet_dla_wirnika1[i] = i + 1;
                }
                //odpowiednio je przesunac - zmiana
                przesun_wirnik_do_pozycji(tablica_wirnikow1, ile_alfabet_dla_wirnika, ustawienia_zadan[1], alfabet);
                przesun_wirnik_do_pozycji(tablica_wirnikow1, ile_alfabet_dla_wirnika, 2, alfabet);
                przesun_wirnik_do_pozycji(tablica_wirnikow2, ile_alfabet_dla_wirnika1, ustawienia_zadan[3], alfabet);
                int pozycja_wirnika = (ustawienia_zadan[1]) % alfabet;

                //sprawdzam notche
                bool sa_notche = false;
                bool pozycja = false;
                for (int i = 0; i < alfabet; i++) {
                    if (wirniki_w_maszynie_notche[ktory_wirnik1][i] != 0) {
                        sa_notche = true;
                        break;
                    }
                }

                //i potem kodowac po kolei litery
                int input;
                scanf("%d", &input);
                int index = 0;
                while (input != 0) {
                    //szyfrowanie - kodowanie liter
                    //1.wchodzi liczba - znajduje jej indeks w alfabecie
                    input = tablica_wirnikow1[input-1];
                    //2.szukam indeksu w alfabecie wirnika1 z tą liczbą
                    znajdz_index(ile_alfabet_dla_wirnika, &index, input, alfabet);
                    input = tablica_wirnikow2[index];
                    //3.szukam indeksu w alfabecie wirnika2 z tą liczbą
                    znajdz_index(ile_alfabet_dla_wirnika1, &index, input, alfabet);
                    input = wybrany_reflektor[index];
                    //4.szukam w alfabecie index z tą wartością
                    znajdz_index(ile_alfabet, &index, input, alfabet);
                    input = ile_alfabet_dla_wirnika1[index];
                    //5.szukam indeksu wirnika2 z tą liczbą
                    znajdz_index(tablica_wirnikow2, &index, input, alfabet);
                    input = ile_alfabet_dla_wirnika[index];
                    //6.szukam indexu wirnika1 z ta wartoscią
                    znajdz_index(tablica_wirnikow1, &index, input, alfabet);
                    input = ile_alfabet[index];

                    printf("%d", input);
                    printf(" ");
                    przesun_wirnik_do_pozycji(tablica_wirnikow1, ile_alfabet_dla_wirnika, 2, alfabet);
                    pozycja_wirnika = (pozycja_wirnika + 1) % alfabet;
                    for(int i=0; i<alfabet; i++) {
                        if(pozycja_wirnika == i && wirniki_w_maszynie_notche[ktory_wirnik1][i]!=0) {
                            pozycja = true;
                            break;
                        }
                    }
                    if (sa_notche == true && pozycja == true) {
                        przesun_wirnik_do_pozycji(tablica_wirnikow2, ile_alfabet_dla_wirnika1, 2, alfabet);
                        pozycja = false;
                    }
                    scanf("%d", &input);
                }
                printf("\n");
                //in ilosc wirnikow
                //in numer wirnika i ustawienie parami tyle razy ile wirnikow
                //in numer reflektora
                //in literka
                //zwalnianie pamieci
                free(tablica_wirnikow1);
                free(tablica_wirnikow2);
                free(ile_alfabet_dla_wirnika1);
                break;
            }

            default: {
                int** tablica_wirnikow = (int**)calloc(ile_wirnikow_koduje, sizeof(*tablica_wirnikow));
                int** alfabet_dla_wirnika = (int**)calloc(ile_wirnikow_koduje, sizeof(*alfabet_dla_wirnika));
                int* ktory_wirnik = (int*)calloc(ile_wirnikow_koduje, sizeof(int));
                for (int i = 0; i < ile_wirnikow_koduje; i++) {
                    tablica_wirnikow[i] = (int*)calloc(alfabet, sizeof(tablica_wirnikow[0]));
                    alfabet_dla_wirnika[i] = (int*)calloc(alfabet, sizeof(alfabet_dla_wirnika[0]));
                    ktory_wirnik[i] = ustawienia_zadan[i * 2];
                }
                for (int i = 0; i < ile_wirnikow_koduje; i++) {
                    for (int j = 0; j < alfabet; j++) {
                        tablica_wirnikow[i][j] = wirniki_w_maszynie[ktory_wirnik[i]][j];
                        alfabet_dla_wirnika[i][j] = j + 1;
                    }
                }
                //odpowiednio je przesunac - zmiana
                for (int i = 0; i < ile_wirnikow_koduje; i++) {
                    przesun_wirnik_do_pozycji(tablica_wirnikow[i], alfabet_dla_wirnika[i], ustawienia_zadan[2 * i + 1], alfabet);
                }


                int pozycja_wirnika = (ustawienia_zadan[1]) % alfabet;
                int pozycja_wirnika1 = (ustawienia_zadan[3] - 1) % alfabet;

                //sprawdzam notche
                bool sa_notche = false;
                bool pozycja = false;
                for (int i = 0; i < alfabet; i++) {
                    if (wirniki_w_maszynie_notche[ktory_wirnik[0]][i] != 0) {
                        sa_notche = true;
                        break;
                    }
                }
                bool obrot = false;
                bool obrot0 = false;
                //sprawdzam nowe notche
                bool sa_notche1 = false;
                bool pozycja1 = false;
                for (int i = 0; i < alfabet; i++) {
                    if (wirniki_w_maszynie_notche[ktory_wirnik[1]][i] != 0) {
                        sa_notche1 = true;
                        break;
                    }
                }
                //i potem kodowac po kolei litery
                int input;
                scanf("%d", &input);
                int index = 0;
                while (input != 0) {
                    for(int i=0; i<alfabet; i++) {
                        if(pozycja_wirnika == i && wirniki_w_maszynie_notche[ktory_wirnik[0]][i]!=0) {
                            pozycja = true;
                            break;
                        }
                    }
                    for(int i=0; i<alfabet; i++) {
                        if(pozycja_wirnika1+1 == i && wirniki_w_maszynie_notche[ktory_wirnik[1]][i]!=0) {
                            pozycja1 = true;
                            break;
                        }
                    }
                    if (sa_notche == true && sa_notche1 == true && pozycja1 == true && obrot == true) {
                        przesun_wirnik_do_pozycji(tablica_wirnikow[2], alfabet_dla_wirnika[2], 2, alfabet);
                        przesun_wirnik_do_pozycji(tablica_wirnikow[1], alfabet_dla_wirnika[1], 2, alfabet);
                        przesun_wirnik_do_pozycji(tablica_wirnikow[0], alfabet_dla_wirnika[0], 2, alfabet);
                        pozycja_wirnika = (pozycja_wirnika + 1) % alfabet;
                        pozycja_wirnika1 = (pozycja_wirnika1 + 1) % alfabet;
                        pozycja1 = false;
                    } else if (sa_notche == true && pozycja == true && obrot0 == true) {
                        przesun_wirnik_do_pozycji(tablica_wirnikow[1], alfabet_dla_wirnika[1], 2, alfabet);
                        pozycja_wirnika1 = (pozycja_wirnika1 + 1) % alfabet;
                        przesun_wirnik_do_pozycji(tablica_wirnikow[0], alfabet_dla_wirnika[0], 2, alfabet);
                        pozycja_wirnika = (pozycja_wirnika + 1) % alfabet;
                        obrot = true;
                        pozycja = false;
                    } else {
                        przesun_wirnik_do_pozycji(tablica_wirnikow[0], alfabet_dla_wirnika[0], 2, alfabet);
                        pozycja_wirnika = (pozycja_wirnika + 1) % alfabet;
                        obrot0 = true;
                    }
                    pozycja = false;
                    pozycja1 = false;
                    //szyfrowanie - kodowanie liter
                    //1.wchodzi liczba - znajduje jej indeks w alfabecie
                    index=input-1;
                    for (int i = 0; i < ile_wirnikow_koduje; i++) {
                        input = tablica_wirnikow[i][index];
                        //2.szukam indeksu w alfabecie wirnika[i] z tą liczbą
                        znajdz_index(alfabet_dla_wirnika[i], &index, input, alfabet);
                    }
                    input = wybrany_reflektor[index];
                    //5.szukam w alfabecie index z tą wartością
                    znajdz_index(ile_alfabet, &index, input, alfabet);
                    for (int i = ile_wirnikow_koduje - 1; i >= 0; i--) {
                        input = alfabet_dla_wirnika[i][index];
                        //2.szukam indeksu wirnika[i] z tą liczbą
                        znajdz_index(tablica_wirnikow[i], &index, input, alfabet);
                    }
                    input = ile_alfabet[index];

                    printf("%d", input);
                    printf(" ");

                    scanf("%d", &input);
                }
                printf("\n");
                //in ilosc wirnikow
                //in numer wirnika i ustawienie parami tyle razy ile wirnikow
                //in numer reflektora
                //in literka
                //zwalnianie pamieci
                free(ktory_wirnik);
                free(tablica_wirnikow);
                free(alfabet_dla_wirnika);
                break;
            }
        }
        //zwalnianie pamieci
        free(ustawienia_zadan);
        free(wybrany_reflektor);
    }

    //zwalnianie pamieci - free
    free(ile_alfabet);
    free(ile_alfabet_dla_wirnika);
    free(wirniki_w_maszynie);
    free(wirniki_w_maszynie_notche);
    free(reflektory_w_maszynie);

    return 0;
}