/** @author wasd
    @date 14/11/2018 */
#include <iostream>
#include <queue>

template <typename T>
class Stack {
 public:
  Stack() = default;

  ~Stack() {
    delete head_;
  }

  T Top() const {
    return head_->value;
  }

  bool IsEmpty() const {
    return head_ == nullptr;
  }

  int GetSize () const {
    return size_;
  }

  void Push(const T& value) {
    Node* node = new Node;
    ++size_;
    node->value = value;
    node->next = head_;
    head_ = node;
  }

  void Pop() {
    if(!IsEmpty()) {
      --size_;
      Node* temp = head_;
      head_ = temp->next;
      temp->next = nullptr;
      delete temp;
    }
  }

  void Clear() {
    delete head_;
    head_ = nullptr;
  }

 private:
  struct Node {
    ~Node() {
      if (next != nullptr) {
        delete next;
      }
    }

    T value;
    Node* next = nullptr;
  };

  Node* head_ = nullptr;
  int size_ = 0;
};

template <typename T>
class Queue {
 public:
  Queue() = default;

  void Enqueue(const T& value) {
    stack1.Push(value);
    ++size_;
  }

  void Dequeue() {
    if (stack2.IsEmpty() && !stack1.IsEmpty()) {
      while (!stack1.IsEmpty()) {
        stack2.Push(stack1.Top());
        stack1.Pop();
      }
    }
    if (!stack2.IsEmpty()) {
      stack2.Pop();
    }
    --size_;
  }

  T Front() {
    if (stack2.IsEmpty() && !stack1.IsEmpty()) {
      while (!stack1.IsEmpty()) {
        stack2.Push(stack1.Top());
        stack1.Pop();
      }
    }
    return stack2.Top();
  }

  int GetSize() const {
    return size_;
  }

  bool IsEmpty() const {
    return size_ == 0;
  }

  void Clear() {
    stack1.Clear();
    stack2.Clear();
  }

 private:
  Stack<T> stack1;
  Stack<T> stack2;
  int size_ = 0;
};

int WhoWouldWin(Queue<int>& queue1, Queue<int>& queue2, int& counter) {
  int temp = 0;
  while (counter != 1000000) {
    if (queue1.IsEmpty()) {
      return 2;
    }
    if (queue2.IsEmpty()) {
      return 1;
    }

    ++counter;

    if ((queue1.Front() > queue2.Front()) || (queue1.Front() == 0 && queue2.Front() == 9)) {
      temp = queue1.Front();
      queue1.Enqueue(temp);
      queue1.Dequeue();

      temp = queue2.Front();
      queue1.Enqueue(temp);
      queue2.Dequeue();
    } else {
      if ((queue1.Front() < queue2.Front()) || (queue2.Front() == 0 && queue1.Front() == 9)) {
        temp = queue2.Front();
        queue2.Enqueue(temp);
        queue2.Dequeue();

        temp = queue1.Front();
        queue2.Enqueue(temp);
        queue1.Dequeue();
      }
    }

    int temp = 0;
    for(int i = 1; i <= 5; ++i) {
      std::cout << queue1.Front() << " ";
      temp = queue1.Front();
      queue1.Dequeue();
      queue1.Enqueue(temp);
    }
    std::cout << std::endl;
    for(int i = 1; i <= 5; ++i) {
      std::cout << queue2.Front() << " ";
      temp = queue2.Front();
      queue2.Dequeue();
      queue2.Enqueue(temp);
    }
    std::cout << std::endl << std::endl;

    if (counter == 1) {
      break;
    }

  }

  return 0;
}

int main() {
  Queue<int> queue1;
  Queue<int> queue2;

  int temp = 0;
  for(int i = 1; i <= 5; ++i) {
    std::cin >> temp;
    queue1.Enqueue(temp);
  }
  for(int i = 1; i <= 5; ++i) {
    std::cin >> temp;
    queue2.Enqueue(temp);
  }

  int counter = 0;
  int result = WhoWouldWin(queue1, queue2, counter);

  if (result == 1) {
    std::cout << "first " << counter;
  }
  if (result == 2) {
    std::cout << "second " << counter;
  }
  if (result == 0) {
    std::cout << "botva";
  }

  return 0;
}