[ADS] StackQueue

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;

public class StackQueue {
    int stackSize;
    int stackElems[];

    int queueSize;
    int front, rear;
    int queueElems[];

    public StackQueue(int maxStackSize, int maxQueueSize) {
        clearStack();
        clearQueue();
        stackElems = new int[maxStackSize];
        queueElems = new int[maxQueueSize];
    }

    public void clearStack(){
        for (int i = 0; i < stackSize; i++) {
            stackElems[i] = 0;
        }
        stackSize = 0;
    }

    public void clearQueue(){
        queueSize = 0;
        front = 0;
        rear = 0;
    }

    public boolean stackIsEmpty() {
        return stackSize == 0;
    }

    public boolean queueIsEmpty() {
        return queueSize == 0;
    }


    public boolean isEmpty() {
        return stackIsEmpty() && queueIsEmpty();
    }

    public void push(int add){
        stackElems[stackSize++] = add;
    }
    public int pop(){
        int top = stackElems[--stackSize];
        stackElems[stackSize] = -1;
        return top;
    }
    public void enqueue(int add){
        queueElems[rear++] = add;
        if (rear == queueElems.length) {
            rear = 0;
        }
        queueSize++;
    }
    public int dequeue () {
        // Go otstranuva i vrakja pochetniot element na redicata.
        if (queueSize > 0) {
            int frontmost = queueElems[front];
            queueElems[front++] = -1;
            if (front == queueElems.length)  front = 0;
            queueSize--;
            return frontmost;
        }
        return 0;
    }

    public void insertElement(int insert) {
        if (stackSize != stackElems.length) {
            push(insert);
        } else if (queueSize != queueElems.length){
            enqueue(insert);
        }
    }

    public int deleteElement(){
        if (!isEmpty()){
            int stackTemp = stackPeek();
            int queueTemp = queuePeek();
            if (stackTemp > queueTemp){
                return pop();
            } else {
                return dequeue();
            }
        } else if (stackIsEmpty()){
            return dequeue();
        } else if (queueIsEmpty()){
            return pop();
        }
        return -1;
    }

    public int stackPeek(){
        return stackElems[stackSize - 1];
    }
    public int queuePeek(){
        return queueElems[front];
    }

    public int peek(){
        if (!isEmpty()){
            int stackTemp = stackPeek();
            int queueTemp = queuePeek();
            if (stackTemp > queueTemp){
                return stackTemp;
            } else {
                return queueTemp;
            }
        } else if (stackIsEmpty()){
            return queuePeek();
        } else if (queueIsEmpty()){
            return stackPeek();
        }
        return -1;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int stackSize = Integer.parseInt(br.readLine());
        int queueSize = Integer.parseInt(br.readLine());
        int N = Integer.parseInt(br.readLine());
        StackQueue stackqueue = new StackQueue(stackSize, queueSize);

        for (int i = 0; i < N; i++) {
            stackqueue.insertElement(Integer.parseInt(br.readLine()));
        }

        System.out.println(stackqueue.peek());

        for (int i = 0; i < N; i++) {
            System.out.print(stackqueue.peek() + " ");
            stackqueue.deleteElement();
        }
    }
}