//genericki red
import java.util.LinkedList;
import java.util.Scanner;

class EmptyQueueException extends RuntimeException{}


class Node<T>
{
	T element;
	Node<T> next;
	Node(T element, Node<T> next)
	{
		this.element = element;
		this.next = next;
	}

	public T getElement()
	{
		return element;
	}
	public Node<T> getNext()
	{
		return next;
	}

	public void setNext(Node<T> next)
	{
		this.next = new Node<T>(next.element, next);
	}

}
class Queue<T>
{
	Node<T> first, last;
	int count;
	public Queue()
	{
		first = last = null;
		count = 0;
	}

	public boolean isEmpty()
	{
		return count == 0;
	}

	public void enqueue(T element)
	{
		if(this.isEmpty())
			first = last = new Node<T>(element, null);
		else
			{
			last.setNext(new Node<T>(element, null));
			last = last.next;
			}

		count++;
	}

	public T dequeue()
	{
		if(count == 0)
			throw new EmptyQueueException();

		T element = first.element;
		first = first.next;
		count--;
		return element;
	}

	public T peek()
	{
		if(count==0)
			throw new EmptyQueueException();
		return first.element;
	}

	public T inspect()
	{
		if(count==0)
			throw new EmptyQueueException();
		return last.element;
	}

	public int count()
	{

		return count;
	}
}

public class QueueTest {


    public static void main(String[] args) throws EmptyQueueException {
        Scanner scanner = new Scanner(System.in);
        int numberOfElements = scanner.nextInt();
        if (numberOfElements == 0) { //Simple test case with one int element
            int element = scanner.nextInt();
            Queue<Integer> queue = new Queue<>();
            System.out.println("Queue empty? : " + queue.isEmpty());
            System.out.println("Queue count? : " + queue.count());
            System.out.println("Queue enqueue: " + element);
            queue.enqueue(element);
            System.out.println("Queue empty? : " + queue.isEmpty());
            System.out.println("Queue count? : " + queue.count());
            System.out.println("Queue dequeue? : " + queue.dequeue());
            System.out.println("Queue empty? : " + queue.isEmpty());
            System.out.println("Queue count? : " + queue.count());
        } else if (numberOfElements == 1) { //a more complex test with strings
            Queue<String> queue = new Queue<>();
            int counter = 0;
            while (scanner.hasNextInt()) {
                String t = scanner.next();
                queue.enqueue(t);
                ++counter;
            }
            for (int i = 0; i < counter; ++i) {
                System.out.println(queue.dequeue());
            }
            queue.enqueue(scanner.next());
            System.out.println("Queue inspect? : " + queue.inspect());
            System.out.println("Queue peek? : " + queue.peek());
            queue.enqueue(queue.dequeue());
            queue.enqueue(scanner.next());
            System.out.println("Queue inspect? : " + queue.inspect());
            System.out.println("Queue peek? : " + queue.peek());
        } else if (numberOfElements == 2) {
            Queue<String> queue = new Queue<>();
            String next;
            int counter = 0;
            while (true) {
                next = scanner.next();
                if (next.equals("stop")) break;
                queue.enqueue(next);
                ++counter;
            }
            while (!queue.isEmpty()) {
                if (queue.count() < counter) System.out.print(" ");
                System.out.print(queue.dequeue());
            }
        } else if (numberOfElements == 3) { //random testing
            Queue<Double> queue = new Queue<>();
            LinkedList<Double> linkedQueue = new LinkedList<>();
            boolean flag = true;
            int n = scanner.nextInt();
            for (int i = 0; i < n; ++i) {
                double q = Math.random();
                if (q < 0.5) {
                    double t = Math.random();
                    queue.enqueue(t);
                    linkedQueue.addFirst(t);
                }
                if (q < 0.8&&q >= 0.5) {
                    if (!linkedQueue.isEmpty()) {
                        double t1 = linkedQueue.removeLast();
                        double t2 = queue.dequeue();
                        flag &= t1 == t2;
                    } else {
                        flag &= linkedQueue.isEmpty() == queue.isEmpty();
                    }
                }
                if (q < 0.9 && q >= 0.8) {
                    if (!linkedQueue.isEmpty()) {
                        double t1 = linkedQueue.peekLast();
                        double t2 = queue.peek();
                        flag &= t1 == t2;
                    } else {
                        flag &= linkedQueue.isEmpty() == queue.isEmpty();
                    }
                }
                if (q < 1 && q >= 0.9) {
                    if (!linkedQueue.isEmpty()) {
                        double t1 = linkedQueue.peekFirst();
                        double t2 = queue.inspect();
                        flag &= t1 == t2;
                    } else {
                        flag &= linkedQueue.isEmpty() == queue.isEmpty();
                    }
                }
                flag &= linkedQueue.size() == queue.count();
            }
            System.out.println("Compared to the control queue the results were the same? : " + flag);
        } else if (numberOfElements == 4) { //performance testing
            Queue<Double> queue = new Queue<>();
            int n = scanner.nextInt();
            for (int i = 0; i < n; ++i) {
                if (Math.random() < 0.5) {
                    queue.enqueue(Math.random());
                } else {
                    if (!queue.isEmpty()) {
                        queue.dequeue();
                    }
                }
            }
            System.out.println("You implementation finished in less then 3 seconds, well done!");
        } else if (numberOfElements == 5) { //Exceptions testing
            Queue<String> queue = new Queue<>();
            try {
                queue.dequeue();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                queue.peek();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
            try {
                queue.inspect();
            } catch (Exception e) {
                System.out.println(e.getClass().getSimpleName());
            }
        }
    }

}