#include <iostream>
using namespace std;

class Stack {
private:
    int *arr;
    int top;
    int max_size;

public:
    Stack(int size) {
        arr = new int[size];
        max_size = size;
        top = -1;
    }

    ~Stack() {
        delete[] arr;
    }

    void push(int val) {
        if (top < max_size - 1) {
            top++;
            arr[top] = val;
        }
    }

    int pop() {
        if (top >= 0) {
            int val = arr[top];
            top--;
            return val;
        }
        return -1;
    }

    int peek() {
        if (top >= 0) {
            return arr[top];
        }
        return -1;
    }

    bool is_empty() {
        return top < 0;
    }

    bool is_full() {
        return top == max_size - 1;
    }
};

class Queue {
private:
    Stack enq_stack;
    Stack deq_stack;

public:
    Queue(int size) : enq_stack(size), deq_stack(size) {}

    void enqueue(int val) {
        if (!deq_stack.is_empty()) {
            while (!deq_stack.is_empty()) {
                enq_stack.push(deq_stack.pop());
            }
        }
        enq_stack.push(val);
    }

    int dequeue() {
        if (!enq_stack.is_empty()) {
            while (!enq_stack.is_empty()) {
                deq_stack.push(enq_stack.pop());
            }
        }
        return deq_stack.pop();
    }

    int front() {
        if (!enq_stack.is_empty()) {
            while (!enq_stack.is_empty()) {
                deq_stack.push(enq_stack.pop());
            }
        }
        return deq_stack.peek();
    }

    bool is_empty() {
        return enq_stack.is_empty() && deq_stack.is_empty();
    }

    bool is_full() {
        return enq_stack.is_full() || deq_stack.is_full();
    }
};

int main() {
    Queue q(5);

    // Test enqueue
    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);
    q.enqueue(4);
    q.enqueue