import java.util.Scanner;

// Node class for LinkedList-based stack
class Node<T> {
    T data;
    Node<T> next;

    public Node(T data) {
        this.data = data;
        this.next = null;
    }
}

// Generic stack implemented using arrays
class GenericStackArray<T> {
    private T[] stackArray;
    private int top;
    private int maxSize;

    @SuppressWarnings("unchecked")
    public GenericStackArray(int size) {
        this.maxSize = size;
        this.stackArray = (T[]) new Object[maxSize];
        this.top = -1;
    }

    public void push(T item) {
        if (top < maxSize - 1) {
            stackArray[++top] = item;
        } else {
            System.out.println("Stack Overflow");
        }
    }

    public T pop() {
        if (top >= 0) {
            return stackArray[top--];
        } else {
            System.out.println("Stack Underflow");
            return null;
        }
    }

    public boolean isEmpty() {
        return top == -1;
    }
}

// Generic stack implemented using linked lists
class GenericStackLinkedList<T> {
    private Node<T> top;

    public GenericStackLinkedList() {
        this.top = null;
    }

    public void push(T item) {
        Node<T> newNode = new Node<>(item);
        newNode.next = top;
        top = newNode;
    }

    public T pop() {
        if (top == null) {
            System.out.println("Stack Underflow");
            return null;
        }
        T data = top.data;
        top = top.next;
        return data;
    }

    public boolean isEmpty() {
        return top == null;
    }
}

public class GenericStackExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Testing stack with array implementation
        GenericStackArray<Integer> intStackArray = new GenericStackArray<>(5);
        GenericStackArray<Double> doubleStackArray = new GenericStackArray<>(5);
        GenericStackArray<String> stringStackArray = new GenericStackArray<>(5);

        intStackArray.push(1);
        intStackArray.push(2);
        intStackArray.push(3);
        System.out.println("Popped from intStackArray: " + intStackArray.pop());

        doubleStackArray.push(1.1);
        doubleStackArray.push(2.2);
        doubleStackArray.push(3.3);
        System.out.println("Popped from doubleStackArray: " + doubleStackArray.pop());

        stringStackArray.push("Hello");
        stringStackArray.push("World");
        System.out.println("Popped from stringStackArray: " + stringStackArray.pop());

        // Testing stack with linked list implementation
        GenericStackLinkedList<Integer> intStackLinkedList = new GenericStackLinkedList<>();
        GenericStackLinkedList<Double> doubleStackLinkedList = new GenericStackLinkedList<>();
        GenericStackLinkedList<String> stringStackLinkedList = new GenericStackLinkedList<>();

        intStackLinkedList.push(1);
        intStackLinkedList.push(2);
        intStackLinkedList.push(3);
        System.out.println("Popped from intStackLinkedList: " + intStackLinkedList.pop());

        doubleStackLinkedList.push(1.1);
        doubleStackLinkedList.push(2.2);
        doubleStackLinkedList.push(3.3);
        System.out.println("Popped from doubleStackLinkedList: " + doubleStackLinkedList.pop());

        stringStackLinkedList.push("Hello");
        stringStackLinkedList.push("World");
        System.out.println("Popped from stringStackLinkedList: " + stringStackLinkedList.pop());

        scanner.close();
    }
}