#include <stdio.h>
#include <algorithm>

class List {
public:
  virtual int head() = 0;

  virtual List* tail() = 0;

  virtual ~List() {}
};

List* emptyList = nullptr;

class StoredList : public List {
  int storedHead;
  List* storedTail;
public:
  StoredList(int head, List* tail) {
    storedHead = head;
    storedTail = tail;
  }

  int head() {
    return storedHead;
  }

  List* tail() {
    return storedTail;
  }
};

List* readList() {
  int val;
  scanf("%d", &val);
  if (val != 0)
    return new StoredList(val, readList());
  else
    return emptyList;
}

void printFirst(List* list, int count) {
  if (list == emptyList && count >= 0)
    printf(".\n");
  else if (list != emptyList && count == 0)
    printf("...\n");
  else {
    printf("%d ", list->head());
    printFirst(list->tail(), count - 1);
  }
}

List* lazyInterleave(List* list1, List* list2);

class InterleavedList : public List {
private:
  List* list1;
  List* list2;
public:
  InterleavedList(List* list1, List* list2) {
    this->list1 = list1;
    this->list2 = list2;
  }

  int head() {
    return std::min(list1->head(), list2->head());
  }

  List* tail() {
    if (list1->head() < list2->head())
      return lazyInterleave(list1->tail(), list2);
    else
      return lazyInterleave(list1, list2->tail());
  }
};

List* lazyInterleave(List* list1, List* list2) {
  if (list1 == emptyList)
    return list2;
  else if (list2 == emptyList)
    return list1;
  else
    return new InterleavedList(list1, list2);
}

List* lazyEvenElements(List* list);

class OddElementsList : public List {
private:
  List* list;
public:
  OddElementsList(List* list) {
    this->list = list;
  }

  int head() {
    return list->head();
  }

  List* tail() {
    return lazyEvenElements(list->tail());
  }
};

List* lazyOddElements(List* list) {
  if (list == emptyList)
    return emptyList;
  else
    return new OddElementsList(list);
}

List* lazyEvenElements(List* list) {
  if (list == emptyList || list->tail() == emptyList)
    return emptyList;
  else
    return new OddElementsList(list->tail());
}

List* lazyFilterList(List* list, bool filter(int));

class FilterList : public List {
private:
  List* list;
  bool (*filter)(int);
public:
  FilterList(List* list, bool filter(int)) {
    this->list = list;
    this->filter = filter;
  }

  int head() {
    return list->head();
  }

  List* tail() {
    return lazyFilterList(list->tail(), filter);
  }
};

List* lazyFilterList(List* list, bool filter(int)) {
  if (list == emptyList)
    return emptyList;
  else if (!filter(list->head()))
    return lazyFilterList(list->tail(), filter);
  else
    return new FilterList(list, filter);
}

bool isEven(int value) {
  return value % 2 == 0;
}

int main() {
  List* list1 = readList();
  List* list2 = readList();
  printFirst(list1, 3);
  printFirst(list2, 3);
  List* list3 = lazyInterleave(list1, list2); // O(1)
  printFirst(list3, 3);
  List* list4 = lazyOddElements(list1); // O(1)
  List* list5 = lazyEvenElements(list1); // O(1)
  printFirst(list4, 3);
  printFirst(list5, 3);
  List* list6 = lazyOddElements(list3); // O(1)
  printFirst(list6, 10);
  List* list7 = lazyFilterList(list6, isEven); // O(1)
  printFirst(list7, 10);
}

/*
List list1
List list2
List list4 = interleave(list1, list2) // O(1) T si S
List list3 = concat(list1, list2) // O(1) timp si spatiu
List list5 = oddElements(list4) // O(1) T si S
List list6 = filterPrime(list5) // O(1) T si S

printFirst(List, int counter) // cat mai repede
//*/