#include<bits/stdc++.h>  // 包含所有标准库头文件
using namespace std;    // 使用标准命名空间

int main(){
    queue<int> q;       // 声明一个整数类型的队列q
    int n;              // 定义变量n，表示操作次数
    cin >> n;           // 输入操作次数n
    
    // 循环处理n次操作
    while(n--){
        int x;         // 定义变量x，表示操作类型
        cin >> x;       // 输入操作类型x
        
        // 根据操作类型x执行不同操作
        switch(x){
            case 1:     // 操作1：入队操作
                int c;  // 定义变量c，表示要入队的元素
                cin >> c;  // 输入要入队的元素c
                q.push(c); // 将元素c加入队尾
                break;
                
            case 2:     // 操作2：出队操作
                if(q.empty()){  // 检查队列是否为空
                    cout << "ERR_CANNOT_POP" << endl;  // 队列为空，无法出队
                    break;
                }
                q.pop();        // 队列不为空，移除队首元素
                break;
                
            case 3:     // 操作3：查询队首元素
                if(q.empty()){  // 检查队列是否为空
                    cout << "ERR_CANNOT_QUERY" << endl;  // 队列为空，无法查询
                    break;
                }
                cout << q.front() << endl;  // 队列不为空，输出队首元素
                break;
                
            case 4:     // 操作4：查询队列大小
                cout << q.size() << endl;  // 输出队列中元素的数量
                break;
        }
    }
    
    return 0;  // 程序正常结束
}

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 初始化一个整数队列，使用LinkedList实现
        Queue<Integer> q = new LinkedList<>();
        // 创建Scanner对象用于读取输入
        Scanner sc = new Scanner(System.in);
        
        // 读取操作次数n
        int n = sc.nextInt();
        
        // 循环处理n个操作
        while (n-- > 0) {
            // 读取操作类型x
            int x = sc.nextInt();
            
            // 根据操作类型执行相应操作
            switch (x) {
                case 1:  // 入队操作
                    // 读取要入队的元素c
                    int c = sc.nextInt();
                    // 将元素c加入队尾
                    q.add(c);
                    break;
                    
                case 2:  // 出队操作
                    if (q.isEmpty()) {
                        // 队列为空时输出错误信息
                        System.out.println("ERR_CANNOT_POP");
                    } else {
                        // 移除队首元素
                        q.poll();
                    }
                    break;
                    
                case 3:  // 查询队首元素
                    if (q.isEmpty()) {
                        // 队列为空时输出错误信息
                        System.out.println("ERR_CANNOT_QUERY");
                    } else {
                        // 获取但不移除队首元素并输出
                        System.out.println(q.peek());
                    }
                    break;
                    
                case 4:  // 查询队列大小
                    // 输出队列当前元素数量
                    System.out.println(q.size());
                    break;
            }
        }
        
        // 关闭Scanner对象释放资源
        sc.close();
    }
}

from collections import deque
import sys

def main():
    # 初始化双端队列作为队列使用
    q = deque()
    # 读取所有输入行
    lines = sys.stdin.read().split()
    ptr = 0  # 指针跟踪当前读取位置
    
    # 读取操作次数n
    n = int(lines[ptr])
    ptr += 1
    
    # 循环处理n个操作
    for _ in range(n):
        # 读取操作类型x
        x = int(lines[ptr])
        ptr += 1
        
        if x == 1:  # 入队操作
            # 读取要入队的元素c
            c = int(lines[ptr])
            ptr += 1
            # 将元素c加入队尾
            q.append(c)
            
        elif x == 2:  # 出队操作
            if not q:
                # 队列为空时输出错误信息
                print("ERR_CANNOT_POP")
            else:
                # 移除队首元素
                q.popleft()
                
        elif x == 3:  # 查询队首元素
            if not q:
                # 队列为空时输出错误信息
                print("ERR_CANNOT_QUERY")
            else:
                # 获取但不移除队首元素并输出
                print(q[0])
                
        elif x == 4:  # 查询队列大小
            # 输出队列当前元素数量
            print(len(q))

if __name__ == "__main__":
    main()