[포인터 코드]

#include <iostream>
using namespace std;

class Node {
    int data;
    Node* link;

public:
    Node(int val) { data = val; link = NULL; }
    Node* getLink() { return link; }
    void setLink(Node* next) {
        link = next;
    }
    void display() {
        cout << data << endl;
    }
};

class LinkedQueue {
    Node* front;
    Node* rear;

public:
    LinkedQueue() : front(NULL), rear(NULL) { }	// front=NULL; rear=NULL;
    ~LinkedQueue() { while (!isEmpty()) delete dequeue(); }
    bool isEmpty() { return front == NULL; }	// 큐가 비어 있는지 체크

    // 삽입 연산: 큐의 마지막 노드 삽입
    void enqueue(Node* p) {
        if (isEmpty()) front = rear = p;	// 공백 상태 삽입	
        else {									// 비공백 상태 삽입
            rear->setLink(p); 				// (1) 
            rear = p;							// (2)	
        }
    }

	// 삭제 연산: 큐의 첫번째 노드 삭제
    Node* dequeue() {
        if (isEmpty()) return NULL;
        Node* temp = front;				// (1) 
        front = front->getLink();			// (2) or NULL
        if (front == NULL) rear = NULL;	// 노드 1개인 경우
        return temp;
    }

	// 검색 연산: 큐의 첫번째 노드 반환
    Node* peek() { 
        if (isEmpty()) return NULL;
        else
            return front;
    }

	// 큐의 모든 요소들을 출력
    void display() {
        cout << "[큐 내용] : " << endl;
            for (Node* p = front; p != NULL; p = p->getLink())
                p->display();
        cout << endl;
    }

	// 삽입 연산: 큐의 첫번째에 노드 삽입
    void enqueueFront(Node* p) {
        if (isEmpty()) front = rear = p;	//공백일때
        else {
            p->setLink(front);
            front = p;
        }
    }

	// 삭제 연산: 큐의 마지막 노드 삭제
    Node* dequeueRear() {
        if (isEmpty()) return NULL;			//공백일때 삭제 불가하므로 NULL 반환
        Node* lastP = rear;
        if (front == rear) {					//노드 1개일때
            front = rear = NULL;
            return lastP;
        }
        else {
	        Node* p = front;
            while (p->getLink() != rear) {	//마지막 노드의 이전 노드를 찾아서
                p = p->getLink();
            }
            rear = p;							
            rear->setLink(NULL);			//마지막 노드를 이전 노드를 마지막 노드로 만든다.
            return lastP;
        }
    }

	// 접근자 함수: 큐의 마지막 노드 반환
    Node* getRear() {
        if (isEmpty()) return NULL;			//공백일때
        else
            return rear;
    }

	// 삭제 연산: 큐의 앞에서 2번째 노드 삭제
    Node* delete2nd() {
        if (isEmpty()) return NULL;				//리스트가 empty이면 노드 삭제 불가 skip
		Node* secondP = front->getLink();		//삭제할 2번째 노드를 secondP에 저장
        if (secondP == NULL) return NULL;	//노드가 1개인 경우, 2번째 노드가 없어서 
        									//2번째 노드 삭제 불가 skip
        else {									//노드가 2개 이상인 경우,
            Node* p = front;
            for (int i = 0; i < 2; i++) {				//3번째 노드를 찾아서, 
            							//3번째 노드는 NULL일 수도 있다(노드가 2개인 경우)
                p = p->getLink();
            }
            front->setLink(p);			//1번째 노드를 3번째 노드에 연결 (노드가 2개인 경우에서 1번째 노드의 링크는 NULL)
			if (p == NULL) rear = front;//노드가 2개 있을 때,
            	//2번째 노드를 삭제하고 노드가 1개만 남으므르, front와 rear 인덱스 업데이트 필요
            return secondP;				//2번째 노드 반환하여 삭제
        }
    }
};

int main() {
    LinkedQueue que;
    int cnt, num;
    int que_num = 1;

    cin >> cnt;
    for (int i = 0; i < cnt; i++) {
        cin >> num;
        switch (num) {
        case 1:	// 큐의 첫번째에 노드 삽입
            que.enqueueFront(new Node(que_num));
            que_num++;
            break;
        case 2:	// 큐의 마지막 노드 삭제
            delete que.dequeueRear();
            break;
        case 3:	// 큐의 앞에서 2번째 노드 삭제
            delete que.delete2nd();
            break;
        }
    }

    que.display();
    return 0;
}