package mltst;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	
	static int v[] , numberOfElements, log, n, m;
	static int minimums[], globalMinimum;
	static final int MAXM = 1000000000;
	
	private static class PartialArrayMinimum implements Runnable{
		
		private int threadStartIndex;
		private int threadIndex; //thread's number
		public static int numberOfThreads = 0;
		
		
		public PartialArrayMinimum(int startIndex){
			super();
			threadStartIndex = startIndex;
			threadIndex = numberOfThreads++;
		}
		
		public void run(){
			for(int stepLog = threadStartIndex*log, nextSteplog=(threadStartIndex+1)*log , j=stepLog; j<nextSteplog; ++j){
//				System.out.println(v[j]);
				if(v[j]<minimums[threadIndex]){
					minimums[threadIndex] = v[j];
				}
			}
		}
		
	}

	public static void main(String[] args) throws InterruptedException, IOException {
		
		v = new int[200001]; n=0;
		minimums = new int[18];
		for(int i =0; i<18; ++i){
			minimums[i] = MAXM + 1;
		}
		globalMinimum = MAXM + 1;
		
		Scanner sc = new Scanner(new FileReader("heapuri.in"));
		PrintWriter pw = new PrintWriter("heapuri.out","UTF-8");
		m = sc.nextInt(); numberOfElements=n;
		int x, y;
		for(int i = 0; i<m; ++i){
			x = sc.nextInt();
			if(x==1){
				y = sc.nextInt();
				v[n++]=y;
			}
			else if(x==2){
				y = sc.nextInt();
				v[y-1] = MAXM;
			}
			else if(x==3){
				pw.println(((Integer)findMinimum()).toString());
				pw.flush();
			}
		}
				
		sc.close(); pw.close();
	}
	
	public static int findMinimum() throws InterruptedException{
		
		log =(int) (Math.log(n)/Math.log(2)); int i;
		ArrayList<Thread> threads = new ArrayList<Thread>();
		
		for(i = 0 ; (i+1)*log < n; ++i){
			Thread partialMin = new Thread(new PartialArrayMinimum(i));
			threads.add(partialMin);
			partialMin.start();
		}
		
		for(i = i*log; i<n; ++i){
//			System.out.println(v[i]);
			if(v[i]<
					minimums[PartialArrayMinimum.numberOfThreads]) //numberOfThreads will be the number of threads previously declared + 1
				minimums[PartialArrayMinimum.numberOfThreads] = v[i];
		}
		
		for(Thread t:threads)
			t.join();
		
		for(int index=0; index<=PartialArrayMinimum.numberOfThreads; ++index){
			if(minimums[index]<globalMinimum)
				globalMinimum = minimums[index];
		}
		
		for(int i2 =0; i2<18; ++i2){
			minimums[i2] = MAXM + 1;
		}
		
		int aux = globalMinimum;
//		System.out.println(aux);
		
		globalMinimum = MAXM + 1;
		return aux;
		
	}

}