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

# Enter your code here. Read input from STDIN. Print output to STDOUT
class Queue: # Costly DeQueue
    # Queue using two stacks with costly deQueue()
    def __init__(self):
        self.s1 = []  # Stacks
        self.s2 = []  # Stacks
        # Note that for Stacks, we can either do append() or pop()

    # EnQueue item to the queue
    def enQueue(self, x):
        self.s1.append(x)

    # DeQueue item from the queue
    def deQueue(self):
        # if s2 is empty and s1 has elements
        if not self.s2:
            while self.s1:
                self.s2.append(self.s1.pop())
        return self.s2.pop() if self.s2 else None

    def peek(self):
        if not self.s2:
            while self.s1:
                self.s2.append(self.s1.pop())
        return self.s2[-1] if self.s2 else None

queue = Queue()
for i in range(int(input())):
    query = input().split(" ")
    if query[0] == "1": # enqueue
        queue.enQueue(query[1])
    elif query[0] == "2":  # pop (dequeue front element)
        queue.deQueue()
    elif query[0] == "3":  # print
        print(queue.peek())
    else:
        print("ERROR!") # Should never reach here

import java.io.*;
import java.util.*;

/*
a. For insert, insert into stack1.
b. For deque, deque from stack2. If it is not empty transfer from 1 to 2 and deque from 2.
c. For peek, show peek of stack2. If empty transfer from 1 to 2 and then peek from 2.
*/

public class Solution {

    public static Stack<Integer> sta1 = new Stack();
    public static Stack<Integer> sta2 = new Stack();
    
    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        
        // only below is poss in stacks
        // sta1.removeLast();
        Scanner sc = new Scanner(System.in);
        int noQ = sc.nextInt();
        
        while (noQ-- > 0) {
            switch (sc.next()) {
                case "1":
                    insertQueue(sc.nextInt());

                    // print queue top
                    // printQueueHead();
        
                    break;

                case "2":
                    deQueue();
                    break;

                case "3":
                    printQueueHead();
                    break;

                case "q":
                    return;

                default:
                    System.out.println("Invalid input!");
                    break;
            }
        }
    }
    
    public static void insertQueue(int item) {
        sta1.add(item);
    }
    
    public static void transfer() {
        if(sta1.size() == 0)
            return;
        do {
            sta2.push(sta1.pop());
        }while(sta1.size() > 0);
    }
        
    public static Integer deQueue() {

        if(sta2.size() == 0) {
            if(sta1.size() == 0) {
                return null;
            }
            transfer();
        }
        
        return sta2.pop();
    }
    
    // sta1 s last element is the queue head
    public static void printQueueHead(){
        
        if(sta2.size() == 0) {
            if(sta1.size() == 0) {
                return;
            }
            transfer();
        }
        
        System.out.println(sta2.peek());
    }
}

function processData(input) {
  // Define a queue
  class Fifo {
    constructor() {
      this.stackEnqueue = [];
      this.stackDequeue = [];
    }

    enqueue(x) {
      this.stackEnqueue.push(x);
    }

    transfer() {
      while (this.stackEnqueue.length > 0) {
        this.stackDequeue.push(this.stackEnqueue.pop());
      }
    }
    dequeue() {
      if (this.stackDequeue.length === 0) {
        this.transfer();
      }
      this.stackDequeue.pop();
    }
    peek() {
      if (this.stackDequeue.length === 0) {
        this.transfer();
      }
      if (this.stackDequeue.length === 0) {
        return null;
      } else {
        return this.stackDequeue[this.stackDequeue.length - 1];
      }
    }
  }

  let q = new Fifo();

  // Parse input

  const inputs = input.split('\n');

  for (let i = 1; i <= Number(inputs[0]); i++) {
    const element = inputs[i];
    const inputArray = element.split(' ');

    const action = Number(inputArray.shift());
    const value = Number(inputArray.join(''));

    switch (action) {
      case 1:
        q.enqueue(value);
        break;

      case 2:
        q.dequeue();
        break;

      case 3:
        console.log(q.peek());
        break;

      default:
        console.log('DEFAULT REACHED');
        console.log('Unexpected action', action, 'With Value', value);

        break;
    }
  }
}

# Enter your code here. Read input from STDIN. Print output to STDOUT
class LinkedListNode():
    data: int = None
    next: 'LinkedListNode' = None


class Queue():
    def __init__(self):
        self.head = None
        self.tail = None

    def enqueue(self, x):
        final_element = LinkedListNode()
        final_element.data = x
        # Handle empty queue case
        if not self.head:
            self.head = final_element
            if not self.tail:
                self.tail = final_element
        else:
            self.tail.next = final_element
            self.tail = self.tail.next

    def dequeue(self):
        # Handle empty queue case
        if not self.head:
            return None
        dequeue_value = self.head.data
        self.head = self.head.next
        # If queue is empty, remove tail
        if self.head is None:
            self.tail = None
        return dequeue_value

    def handle_query(self, query):
        query_type = query[0]
        # Enqueue query
        if query_type == 1:
            x = query[1]
            self.enqueue(x)
        # Dequeue query
        elif query_type == 2:
            return self.dequeue()
        # Print query
        elif query_type == 3:
            if self.head.data:
                print(self.head.data)
            else:
                print(None)

if __name__ == "__main__":
    q = int(input())
    queue = Queue()
    for _ in range(q):
        query = list(map(int, input().split()))
        queue.handle_query(query)