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

int main() {
    stack<int> Front,Rear;
    int Q;
    cin >> Q;
    while(Q--)
    {
        int type, x;
        cin >> type;
        if(type == 1)
        {
            cin >> x;
            Rear.push(x);
        }    
        else 
        {
           if(Front.empty())
           { // move all the elements from "Rear" stack to "Front" stack
               while(!Rear.empty())
               {
                   Front.push(Rear.top());
                   Rear.pop();
               }   
            }    
           if(!Front.empty())
           {
               if(type == 2) Front.pop();
               if(type == 3) cout << Front.top() << endl;
           }  
        }   
    }    
    return 0;
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int noElements = in.nextInt();
        
        Stack<Integer> one = new Stack<Integer>();
        Stack<Integer> two = new Stack<Integer>();
        
        int command;
        
        for (int i = 0 ; i < noElements ; i++) {
            command = in.nextInt();
            
            if (command == 1)
            {
                one.push(in.nextInt());
            } 
            else if (command == 2)
            {
                if(two.isEmpty())
                {
                    while(!one.isEmpty())
                    {
                        two.push(one.pop());
                    }                    
                }
                
                if (!two.isEmpty()){                                
                    two.pop(); 
                }

            }
            else if (command == 3)
            {       
                if(two.isEmpty())
                {
                    while(!one.isEmpty())
                    {
                        two.push(one.pop());
                    }
                    System.out.println(two.peek());
                } 
                else 
                {
                    System.out.println(two.peek());
                }
            }
        }
    }
}

else if (command == 2)
            {
                while(!one.isEmpty())
                {
                    two.push(one.pop());
                }
                    
                two.pop();
                
                while(!two.isEmpty())
                {
                    one.push(two.pop());
                } 
            }

else if (command == 3)
            {
                while(!one.isEmpty())
                {
                    two.push(one.pop());
                }
                    
                System.out.println(two.peek());
                
                while(!two.isEmpty())
                {
                    one.push(two.pop());
                } 
                
            }

ENQUEUE = 1
DEQUEUE = 2
PRINT = 3

def read_command():
    parts = input().strip().split(' ')
    cmd = int(parts[0])
    
    if len(parts) == 1:
        return (cmd, None)
    try:
        arg = int(parts[1])
    except ValueError:
        arg = parts[1]
        
    return cmd, arg

class Stack:
    def __init__(self):
        self._l = []
        
    def push(self, data):
        self._l.append(data)
        
    def pop(self):
        return self._l.pop()
    
    def __len__(self):
        return len(self._l)
    
    def top(self):
        if self._l:
            return self._l[-1]
        return None

class Queue:
    def __init__(self):
        self._head = Stack()
        self._tail = Stack()
    
    def enqueue(self, data):
        self._tail.push(data)
    
    def dequeue(self):
        if self._head:
            return self._head.pop()
            
        return self._tail_to_head().pop()
    
    def peek(self):
        if self._head:        
            return self._head.top()
            
        return self._tail_to_head().top()
    
    def _tail_to_head(self):
        while self._tail:
            self._head.push(self._tail.pop())          
            
        return self._head

    
def main():
    
    q = Queue()

    n_commands = int(input().strip())
    for _ in range(n_commands):
        command, arg = read_command()
        if command == ENQUEUE:
            q.enqueue(arg)
        elif command == DEQUEUE:
            q.dequeue()
        elif command == PRINT:
            print(q.peek())
            
        
if __name__ == '__main__':
    main()

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

public class Solution {
    public static void main(String[] args) {
        MyQueue<Integer> queue = new MyQueue<Integer>();

        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();

        for (int i = 0; i < n; i++) {
            int operation = scan.nextInt();
            if (operation == 1) {               // enqueue
                queue.enqueue(scan.nextInt());
            } else if (operation == 2) {        // dequeue
                queue.dequeue();
            } else if (operation == 3) {        // print/peek
                System.out.println(queue.peek());
            }
        }
        scan.close();
    }
    
    public static class MyQueue<Integer> {
        private Stack<Integer> stack1 = new Stack<>();
        private Stack<Integer> stack2 = new Stack<>();
        
        public void enqueue(Integer num) {
            stack1.push(num);
        }
        
        public Integer dequeue() {
            if (size() == 0) {
                return null;
            }
            if (stack2.isEmpty()) {
                shiftStacks();
            }
            return stack2.pop();
        }
        
        public Integer peek() {
            if (size() == 0) {
                return null;
            }
            if (stack2.isEmpty()) {
                shiftStacks();
            }
            return stack2.peek();
        }
        
        /* Only shifts stacks if necessary */
        private void shiftStacks() {
            if (stack2.isEmpty()) { // shifting items while stack2 contains items would mess up our queue's ordering
                while ( ! stack1.isEmpty()) {
                    stack2.push(stack1.pop());
                }
            }
        }
        
        public int size() {
            return stack1.size() + stack2.size();
        }
    }
}