#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()

old, new = [], []
for _ in range(int(input())):
    val = list(map(int,input().split()))
    if val[0] == 1:
        new.append(val[1])
    elif val[0] == 2:
        if not old :
            while new : old.append(new.pop())
        old.pop()
    else:
        print(old[-1] if old else new[0])

# Initializing two stacks
stack_in, stack_out = [], []

# Dealing with each line of instructions, seperating it to 3 instructions as explained
for i in range(int(input())):
    
    curr_inst = list(map(int, input().split(" ")))
    op = curr_inst[0]
    
    #1
    if op == 1:
        stack_in.append(curr_inst[1])
    #2
    if op == 2:
        # If stack_out is not empty then pop from it
        if stack_out:
            stack_out.pop()
            continue
        else:
            # Move everything to the out stack:
            while stack_in:
                stack_out.append(stack_in.pop())
            stack_out.pop()
            continue
    #3
    if op == 3:
        if not stack_out:
            print(stack_in[0])
        else:
            print(stack_out[-1])

from collections import deque

q = deque([])
for _ in range(int(input())):
    line = list(map(int,input().split()))
    if line[0] == 1:
        q.append(line[1])
    elif line[0] == 2:
        q.popleft()
    elif line[0] == 3:
        print(q[0])

Stack<int> aStack = new Stack<int>();
Stack<int> bStack = new Stack<int>();

// Number of queries
int q = Convert.ToInt32(Console.ReadLine());

for (int i = 0; i < q; i++)
{
    string[] line_temp = Console.ReadLine().Split(' ');
    int[] line = Array.ConvertAll(line_temp, Int32.Parse);

    if (bStack.Count == 0)
    {
        while (aStack.Count != 0)
            bStack.Push(aStack.Pop());
    }

    // Enqueue
    if (line.Length == 2)
    {
        if (bStack.Count == 0)
            bStack.Push(line[1]);
        else
            aStack.Push(line[1]);
    }
    else
    {
        // Dequeue
        if (line[0] == 2)
            bStack.Pop();
        // Print
        else if (line[0] == 3)
            Console.WriteLine(bStack.Peek());
    }
}

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();
        }
    }
}