#include<iostream>

using namespace std;

struct nodo{
    int info;
    nodo*next;

    nodo(int a=0, nodo*b=0) {
        info=a;
        next=b;
    }
};

// funzioni per input e output
nodo *buildL(int k) {
    if(!k)
        return 0;

    int x;
    cin>>x;
    return new nodo(x,buildL(k-1));
}

void leggiA(int*A,int k) {
    for(int i=0; i<k; i++)
        cin>>A[i];
}

nodo* clone(nodo*L) {
    if(!L)
        return 0;

    return new nodo(L->info,clone(L->next));
}

void stampa(nodo*L) {
    if(!L) {
        cout<<endl;
        return;
    }

    cout<<L->info<<' ';
    stampa(L->next);
}

void Fric(nodo*L, int*A, int dimA, nodo*&L1, nodo*&L2);
void concat(nodo*& prima, nodo*& seconda);
nodo* removeSubList(nodo*& start, int lunghezza);

main() {
    cout<<"start"<<endl;

    int n, dimA, A[20];

    cin >> n >> dimA;
    nodo*L=buildL(n);
    stampa(L);

    leggiA(A,dimA);

    nodo*X=clone(L);
    nodo*L1=0,*L2=0;

    Fric(L,A,dimA,L1,L2);
    stampa(L1);
    stampa(L2);

    stampa(L1);
    stampa(L2);

    cout<<"end"<<endl;
}

/* PRE=(lista(L), lista(L1), e lista(L2) sono ben formate,
    A contiene dimA elementi non negativi,
    con dimA pari >=0, vL=lista(L),vL1=lista(L1),vL2=lista(L2)) */
void Fric(nodo*L, int*A, int dimA, nodo*&L1, nodo*&L2) {
    if(!L)
        return;

    if(dimA == 0) { // se ci sono degli elementi restanti
        concat(L1, L);
        return;
    }

    // se L non e' vuota e dimA != 0
    nodo *toAdd = removeSubList(L, A[0]);
    concat(L1, toAdd);
    toAdd = removeSubList(L, A[1]);
    concat(L2, toAdd);

    Fric(L, A+2, dimA-2, L1, L2);
}
/* POST=(i nodi di vL sono distribuiti correttamente su 2 liste X1 e X2 secondo
i valori di A e L1=vL1@X1 e L2=vL2@X2)*/

// funzione per concatenare due liste
void concat(nodo*& prima, nodo*& seconda) {
    if(!prima)
        prima = seconda;
    else
        concat(prima->next, seconda);
}

// una funzione ha lo scopo di individuare la porzione di L da “staccare” per poi aggiungerla ad L1 o ad L2
nodo* removeSubList(nodo*& start, int lunghezza) {
    if(!start || !lunghezza)
        return NULL;

    nodo *toRemove = start;
    start = start->next;
    toRemove->next = removeSubList(start, lunghezza-1);
    return toRemove;
}