e

#include <iostream>
#include <cassert>
#include <string>

using namespace std;

template <class T> class Link;
template <class T> class List;
template <class T> class Iterator;

// ======================================================================
//                    Template Class list
// ======================================================================
template <class T>
class List {
protected:
    Link <T> *first;                // data field

public:
    List() : first(nullptr) {}      // default constructor
    List(const List &source);       // copy constructor
    virtual ~List() {};                // destructor

    virtual void add(T value);      // insert a new item
    virtual void deleteAll();
    T firstElement() const;        // access the first item
    virtual bool includes(T value) const;  // inclusion test
    bool isEmpty() const;
    virtual void removeFirst();

    friend class Iterator <T>;
};
// ======================================================================
//                    Template Class link
// ======================================================================
template <class T>
class Link {
private:
    T value;
    Link <T> *next;

    Link(T val, Link *ptr) : value(val), next(ptr) { }


public:
    Link <T> *insert(T value);      // after current Link

    friend class List <T>;
    friend class Iterator <T>;
};

// ======================================================================
//                    Template Class link - attributes
// ======================================================================
template <class T> Link <T> * Link <T> ::insert(T value) {
    next = new Link <T>(value, next);
    return next;
}

// ======================================================================
//                    Template Class list - attributes
// ======================================================================
template <class T> void List <T> ::add(T value)
{
    first = new Link <T>(value, first);
}

template <class T> T List <T> ::firstElement() const
{
    assert(first != nullptr);
    return first->value;
}


template <class T> bool List <T> ::isEmpty() const
{
    return first == nullptr;
}


template <class T> bool List <T> ::includes(T value) const
{
    for (Link <T> *p = first; p; p = p->next)
        if (value == p->value)return true;
    return false;
}

template <class T> void List <T> ::removeFirst() {
    assert(first != nullptr);
    Link <T> *ptr = first;  // save pointer to the first item
    first = ptr->next;      // reassign the first node
    delete ptr;
}

template <class T> void List <T> ::deleteAll() {
    Link <T> *next;
    for (Link <T> *p = first; p; p = next) {
        next = p->next;
        delete p;
    }
    first = nullptr;
}

template <class T> ostream & operator << (ostream &s, const List<T> &toDisp){
    return s << toDisp.firstElement();
}

template <class T>
class FIFO : public List<T>
{
    public:
        List <T> S1;
        List <T> S2;

        void addToEnd(T value);
        FIFO() : last(nullptr) {}
        virtual void add(T value);
        virtual void removeFirst();
        virtual void swap();
    protected:
        Link <T> *last;
};


template <class T> void FIFO <T> ::add(T value) {
    if (S1.isEmpty()) {
        S1.add(value);
        last = this->first; // handling empty List
    }
    else S1.add(value);
}

template <class T>
void FIFO <T> ::addToEnd(T value) {
    if (last != nullptr)
        last = last->insert(value);
    else
        S1.add(value);
}

template <class T> void FIFO <T> ::removeFirst() {
    S2.removeFirst();
    if (S2.isEmpty()) last = nullptr;
}

template <class T> void FIFO <T> ::swap(){
    while(!S1.isEmpty()){
        S2.add(S1.firstElement());
        S1.removeFirst();
    }
}

template <class T> ostream & operator << (ostream &s, const FIFO<T> &toDisp)
{
    return s << toDisp.S2.firstElement();
}
// ======================================================================
//                            main
// ======================================================================
int main()
{

    FIFO <int> queue;

    int K, L, M, N, number;

    cin >> K;
    for (int i = 0; i < K; i++)
    {
        cin >> number;
        queue.addToEnd(number);
    }

    queue.swap();
    cin >> L;
    for (int i = 0; i < L; i++) {
        queue.removeFirst();
    }

    cin >> M;

    for (int i = 0; i < M; i++)
    {
        cin >> number;
        queue.addToEnd(number);
    }

    cin >> N;

    if(K-L < N)
        queue.swap();

    for (int i = 0; i < N; i++) {
        queue.removeFirst();
    }
    queue.swap();

    while(!queue.S2.isEmpty()){
        cout << queue << " ";
        queue.removeFirst();
    }


    return 1;
}