#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;  // 1. 定义一个空栈 s

    // 2. 删除栈顶元素（前提检查是否为空）
    if (!s.empty()) {
        s.pop();
    } else {
        cout << "栈为空，无法执行出栈操作！" << endl;
    }

    // 3. 压入元素 5
    s.push(5);

    // 4. 压入元素 11
    s.push(11);

    // 5. 输出堆栈大小
    cout << "当前栈大小为：" << s.size() << endl;

    // 6. 压入元素 9
    s.push(9);

    // 7. 弹出所有元素并求和
    int sum = 0;
    while (!s.empty()) {
        sum += s.top();
        s.pop();
    }

    cout << "所有弹出元素的和为：" << sum << endl;

    return 0;
}

import java.util.Stack;

public class StackSimulation {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();  // 1. 定义一个空栈 s

        // 2. 删除栈顶元素（防止异常）
        if (!stack.isEmpty()) {
            stack.pop();
        } else {
            System.out.println("栈为空，无法执行出栈操作！");
        }

        // 3. 压入元素 5
        stack.push(5);

        // 4. 压入元素 11
        stack.push(11);

        // 5. 输出堆栈大小
        System.out.println("当前栈大小为：" + stack.size());

        // 6. 压入元素 9
        stack.push(9);

        // 7. 弹出所有元素并求和
        int sum = 0;
        while (!stack.isEmpty()) {
            sum += stack.pop();
        }

        System.out.println("所有弹出元素的和为：" + sum);
    }
}

from collections import deque

stack = deque()  # 1. 定义一个空栈 s

# 2. 删除栈顶元素（安全判断）
if stack:
    stack.pop()
else:
    print("栈为空，无法执行出栈操作！")

# 3. 压入元素 5
stack.append(5)

# 4. 压入元素 11
stack.append(11)

# 5. 输出堆栈大小
print("当前栈大小为：", len(stack))

# 6. 压入元素 9
stack.append(9)

# 7. 弹出所有元素并求和
total = 0
while stack:
    total += stack.pop()

print("所有弹出元素的和为：", total)

#include <bits/stdc++.h>
using namespace std;

// 具体解决每一组测试数据的函数
void solve() {
    int n;
    cin >> n;  // 读入本组操作次数
    stack<unsigned long long> s;  // 定义一个存储无符号长整型数据的栈
    string op;  // 保存操作类型
    unsigned long long x;  // 被操作的元素（仅在push操作时使用）

    // 循环执行n次操作
    while(n--) {
        cin >> op;  // 读入操作指令
        if(op == "push") {  
            // 如果是push操作，还需要读入一个元素x，并将其压入栈
            cin >> x;
            s.push(x);
        }
        else if(op == "pop") {
            // 如果是pop操作，首先判断栈是否为空
            if(!s.empty()) s.pop();  // 非空则弹出栈顶元素
            else cout << "Empty" << endl;  // 空栈时输出Empty
        }
        else if(op == "query") {
            // 如果是query操作，判断栈是否为空
            if(!s.empty()) cout << s.top() << endl;  // 非空则输出栈顶元素
            else cout << "Anguei!" << endl;  // 空栈时输出Anguei!
        }
        else {
            // 其他情况就是size操作，直接输出栈中元素个数
            cout << s.size() << endl;
        }
    }
}

int main() {
    // 快速输入输出设置，加速cin和cout
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t;
    cin >> t;  // 读入测试数据组数

    // 每组数据分别调用solve()函数进行处理
    while(t--) {
        solve();
    }

    return 0;
}

import java.util.Scanner;
import java.util.Stack;

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

        int T = sc.nextInt(); // 读入测试数据组数
        while (T-- > 0) {
            int n = sc.nextInt(); // 读入本组操作次数
            Stack<Long> stack = new Stack<>(); // 使用Stack类创建一个栈，存储Long型数据

            for (int i = 0; i < n; i++) {
                String op = sc.next(); // 读入操作指令

                if (op.equals("push")) {
                    long x = sc.nextLong(); // push操作需要额外读入一个数字
                    stack.push(x); // 将x压入栈中
                } 
                else if (op.equals("pop")) {
                    // pop操作，先判断栈是否为空
                    if (!stack.isEmpty()) {
                        stack.pop(); // 非空则弹出栈顶元素
                    } else {
                        System.out.println("Empty"); // 空栈时输出Empty
                    }
                } 
                else if (op.equals("query")) {
                    // query操作，查看栈顶元素
                    if (!stack.isEmpty()) {
                        System.out.println(stack.peek()); // 非空则输出栈顶元素
                    } else {
                        System.out.println("Anguei!"); // 空栈时输出Anguei!
                    }
                } 
                else if (op.equals("size")) {
                    // size操作，输出栈内元素个数
                    System.out.println(stack.size());
                }
            }
        }
        sc.close(); // 关闭Scanner
    }
}

import sys

# 使用sys.stdin.readline加速读入
input = sys.stdin.readline

T = int(input())  # 读入测试数据组数
output = []  # 存放所有输出结果，最后统一输出（加速）

for _ in range(T):
    n = int(input())  # 读入本组操作次数
    stack = []  # 初始化一个空栈（使用列表模拟栈）

    for _ in range(n):
        line = input().strip()  # 读入操作指令，并去除多余空白

        if line.startswith("push"):
            # push操作，取出要压入的数字
            _, x = line.split()
            stack.append(x)  # 将元素x压入栈中

        elif line == "pop":
            # pop操作，判断栈是否为空
            if stack:
                stack.pop()  # 非空则弹出栈顶元素
            else:
                output.append("Empty")  # 空栈时输出Empty

        elif line == "query":
            # query操作，查看栈顶元素
            if stack:
                output.append(stack[-1])  # 非空则输出栈顶元素
            else:
                output.append("Anguei!")  # 空栈时输出Anguei!

        elif line == "size":
            # size操作，输出栈的元素数量
            output.append(str(len(stack)))

# 最后统一输出所有结果，避免频繁I/O
print('\n'.join(output))

#include <bits/stdc++.h>
using namespace std;

// 辅助函数：将括号字符转换为数字编码，方便后续比较
int get_id(char c){
    if(c == '(') return 1; // 左小括号映射为1
    if(c == '[') return 2; // 左中括号映射为2
    if(c == ']') return 3; // 右中括号映射为3
    if(c == ')') return 4; // 右小括号映射为4
    return 0; // 其他普通字符映射为0
}

int main(){
    string str;
    cin >> str; // 读入整个字符串
    stack<int> s; // 定义一个栈，存括号类型（数字）
    bool flag = true; // 标记配对是否正确

    // 遍历字符串
    for(int i = 0; i < str.size(); i++){
        int id = get_id(str[i]); // 将字符转成数字
        if(id > 2){
            // 当前字符是右括号
            if(s.empty() || s.top() + id != 5) {
                // 栈空 或 无法配对，失败
                flag = false;
                break;
            }
            else {
                // 成功配对，弹出栈顶
                s.pop();
            }
        } 
        else if(id > 0) {
            // 当前字符是左括号
            s.push(id); // 压入栈中
        }
        // 其他普通字符直接跳过
    }

    // 最终判断：配对过程中无误，且栈空
    if(flag && s.empty()) cout << "true";
    else cout << "false";

    return 0;
}

import java.util.Scanner;
import java.util.Stack;

public class Main {

    // 辅助函数：将括号字符映射为数字编码
    public static int getId(char c) {
        if (c == '(') return 1;
        if (c == '[') return 2;
        if (c == ']') return 3;
        if (c == ')') return 4;
        return 0; // 普通字符
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next(); // 读入字符串
        Stack<Integer> s = new Stack<>();
        boolean flag = true; // 标记配对是否成功

        for (int i = 0; i < str.length(); i++) {
            int id = getId(str.charAt(i));
            if (id > 2) {
                // 当前是右括号
                if (s.isEmpty() || s.peek() + id != 5) {
                    flag = false;
                    break;
                } else {
                    s.pop(); // 成功配对，弹出栈顶元素
                }
            } else if (id > 0) {
                // 当前是左括号
                s.push(id);
            }
            // 普通字符直接跳过
        }

        // 判断最终结果
        if (flag && s.isEmpty()) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

# 辅助函数：将括号字符映射为数字编码
def get_id(c):
    if c == '(':
        return 1
    if c == '[':
        return 2
    if c == ']':
        return 3
    if c == ')':
        return 4
    return 0

def main():
    str_ = input()  # 读入字符串
    s = []  # 使用列表模拟栈
    flag = True  # 标记括号是否配对成功

    for c in str_:
        id_ = get_id(c)  # 转换成对应数字
        if id_ > 2:
            # 是右括号
            if not s or s[-1] + id_ != 5:
                flag = False
                break
            else:
                s.pop()  # 配对成功，弹出栈顶
        elif id_ > 0:
            # 是左括号
            s.append(id_)
        # 普通字符直接跳过

    # 判断最终是否栈空且配对过程中没有出错
    if flag and not s:
        print("true")
    else:
        print("false")

if __name__ == "__main__":
    main()