class Queue:
    
    def __init__(self):
        self.inp = []    # add newcomers to enqueue
        self.out = []    # pop to dequeue, transfer if empty
    
    def transfer(self) -> None:
        """
        Transfer elements from input -> output stack to 
        reverse order of elements and maintain FIFO order.
        Utilising .append() and .pop() which are O(1).
        """
        if not self.out:        # if output stack is empty  
            while self.inp:
                self.out.append(self.inp.pop())
        
    def enqueue(self, x: int) -> None:
        self.inp.append(x)
        
    def dequeue(self) -> int:
        self.transfer()
        return self.out.pop()
        
    def peek(self) -> int:
        self.transfer()
        return self.out[-1]

if __name__ == "__main__":
    
    q = Queue()
    
    n = int(input())    # no. of queries
    for _ in range(n):
        query = list(map(int, input().split()))
        if query[0] == 1:       # queue()
            value = query[1]
            q.enqueue(value)
        elif query[0] == 2:     # dequeue()
            q.dequeue()
        elif query[0] == 3:     # print()
            print(q.peek())     # view element at front of queue

using System.Collections.Generic;

class Solution {
    static void Main(String[] args) {
        (Stack<int> s1, Stack<int> s2) = (new(), new());
        var n = int.Parse(Console.ReadLine());
        for (var _ = 0; _ < n; _++)
        {
            var parameters = Console.ReadLine().Split();
            var operation = parameters[0];
            switch (operation)
            {
                case "1":
                    s2.Push(int.Parse(parameters[1]));
                    break;
                case "2":
                case "3":
                    if (s1.Count == 0)
                    {
                        while (s2.Count > 0)
                        {
                            s1.Push(s2.Pop());
                        }
                    }
                    if (operation == "3")
                    {
                        Console.WriteLine(s1.Peek());
                        break;
                    }
                    s1.Pop();
                    break;
                default:
                    break;
            }
        }
    }
}

function main() {
    const ws: WriteStream = createWriteStream(process.env['OUTPUT_PATH']);
    const querys_count: number = parseInt(readLine().trim(), 10);
    const queues: number[] = []

    for (let i = 0; i < querys_count; i++) {
        let [type, queue] = readLine().split(' ').map(sTemp => parseInt(sTemp, 10));
        switch (type) {
            case 1: queues.push(queue); break;
            case 2: queues.shift(); break;
            case 3: ws.write(queues[0] + '\n'); break;
        }
    }

    ws.end();
}

function processData(input) {
    let queries = input.split('\n');
    let q = parseInt(queries[0]);  
    let stack1 = [];
    let stack2 = [];
    for (let i = 1; i <= q; i++) {
        let query = queries[i].split('  ');
        let type = parseInt(query[0]);
        if (type === 1) {
             
            let x = parseInt(query[1]);
            stack1.push(x);
        } else if (type === 2) {
            if (stack2.length === 0) {
                while (stack1.length > 0) {
                    stack2.push(stack1.pop());
                }
            }
            stack2.pop();
        } else if (type === 3) {
            if (stack2.length === 0) {
                while (stack1.length > 0) {
                    stack2.push(stack1.pop());
                }
            }
            console.log(stack2[stack2.length - 1]);  
        }
    }
}