#include<iostream>
using namespace std;

int& TV(int*p, int lim1,int lim2, int lim3, int f, int n);
void stampa(int*, int, int, int);

int main() {

    int x[100];
    for(int i=0; i<100; i++)
        cin >> x[i];

    int lim1, lim2, lim3;
    cin >> lim1 >> lim2 >> lim3;

    cout << "start" << endl;

    int quadrupla[4];
    int val;
    cin >> val;
    int quadIndex = 0;

    while(val != -1) { // R=(inseriti (quadIndex%4 elementi della quadrupla corrente (quadrupla[0..(quadIndex%4-1)] )
                            // && val e' l'ultimo elemento letto && sono state svolte tutte le modifiche relative alle quadruple lette)
                            // && sono state lette  quadIndex/4 quadruple complete
        quadrupla[quadIndex%4] = val;

        // se ho completato la quadrupla allora svolgo il cambiamento
        if((quadIndex%4) == 3) {

            // quadrupla: i j k z
            // scambio il valore j della vFetta i
            // con il valore z della vFetta k

            int *pVfettaI = x+quadrupla[0];
            int *pVfettaK = x+quadrupla[2];

            int& v1 = TV(pVfettaI, lim1, lim2, lim3, quadrupla[0], quadrupla[1]);
            int& v2 = TV(pVfettaK, lim1, lim2, lim3, quadrupla[2], quadrupla[3]);

            int temp = v1;
            v1 = v2;
            v2 = temp;
        }

        quadIndex++;
        cin >> val;
    }
    // POST=(val == -1 && sono state svolte tutte le modifiche relative alle quadruple lette nell'ordine di lettura presente)

    stampa(x, lim1, lim2, lim3); // stampa Y[lim1][lim2][lim3] per strati

    cout << "end" << endl;

    return 0;
}

// PRE=(p punta al primo elemento della V-fetta f, e gli altri parametri sono ben definiti)
int& TV(int*p, int lim1,int lim2, int lim3, int f, int n) {
    int& cella = *(p+n*lim3);
    return cella;
}
// POST=(la funzione restituisce per riferimento l’elemento n della V-fetta di indice f)

// PRE=(array e' definito && lim1, lim2, lim3 indicano le dimensioni della torta da considerare)
void stampa(int *array, int lim1, int lim2, int lim3) {

    for(int i = 0; i < lim1; i++) { // R=(0<=i<=lim1 && stampati i strati della torta)

        for(int j = 0; j < lim2; j++) { // R=(0<=j<=lim2 && stampate j righe dello strato corrente i)

            for(int k = 0; k < lim3; k++) { // R=(0<=k<=lim3 && stampate k colonne della riga j dello strato i)
                cout << array[i*lim2*lim3+j*lim3+k] << " ";
            }

            cout << endl;
        }
    }
}
// POST=(e' stata stampata la torta richiesta)

/*
    PROVA DI CORRETTEZZA:
        1. INIZIO: quadIndex = 0, viene letto val
            ==> R diventa: sono stati inseriti 0 elementi nella quadrupla corrente && val e' l'ultimo elemento letto
                && sono state lette 0 quadruple complete && sono state svolte tutte le modifiche relative alle quadruple lette (0)
            ==> R viene rispettata

        2. INVARIANZA
            condizione: val != -1
            quindi entro nel ciclo, viene introdotto un ulteriore valore (precedentemente letto) nella quadrupla corrente,
            se a questo punto la quadrupla e' completa, viene richiamata due volte la funzione TV e viene effettuato lo scambio.
            L'indice generale viene incrementato e viene letto un nuovo valore di val.
                => vale quindi R

        3. FINE
            condizione: val == -1
            !(val != -1) => val == -1 => POST

*/