#!/bin/python3

import math
import os
import random
import re
import sys

freq = {} # stores the number and its frequency (e.g., {number: count})
count = {} # stores the number of elements at each frequency (e.g., {count: num_elements})
results = []


def op_1(x): # insert x into your data structure
    
    # save old frequency for x
    old_freq_x = freq.get(x, 0)
    
    # update frequency for x
    freq[x] = old_freq_x + 1
    
    # increment count for new frequency
    count[freq[x]] = count.get(freq[x], 0) + 1
    
    # decrement count for old frequency
    count[old_freq_x] = max(count.get(old_freq_x, 0) - 1, 0)
    
   
def op_2(y): # delete one occurence of y from your data structure
    
    # save old frequency for y
    old_freq_y = freq.get(y, 0)
    
    # update frequency for y
    freq[y] = max(old_freq_y - 1 , 0)
    
    if old_freq_y > freq[y]: # a removal ACTUALLY happened
        # decrement count for old frequency
        count[old_freq_y] = max(count.get(old_freq_y, 0) - 1, 0)
        
    # increment count for the new "reduced" frequency
    count[freq[y]] = count.get(freq[y], 0) + 1
        
    # if freq[y] < 1:
    #     # remove frequency for y, since it's now 0 (optional)
    #     freq.pop(y)
 
    
def op_3(z): # check if any integer is present whose frequency is exactly z?
    results.append(1) if count.get(z, 0) > 0 else results.append(0)
  
  
# operation function pointers
EXEC = {
    1: op_1,
    2: op_2,
    3: op_3,
}


def freqQuery(queries):
    for query in queries:
        EXEC[query[0]](query[1])
    return results

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    q = int(input().strip())
    queries = []

    for _ in range(q):
        queries.append(list(map(int, input().rstrip().split())))

    ans = freqQuery(queries)
    
    fptr.write('\n'.join(map(str, ans)))
    fptr.write('\n')
    fptr.close()

def freqQuery(queries):
    num = {}
    list1 = []
    for i in range(0,q):
        if(queries[i][0] == 1):
            if queries[i][1] in num:
                num[queries[i][1]] = num[queries[i][1]] + 1
            else:
                num[queries[i][1]] = 1
            
        elif(queries[i][0] == 2):
            if queries[i][1] in num:
                 num[queries[i][1]] = num[queries[i][1]] - 1
            else:
                None            
        else :
            
            if queries[i][1] in num.values():
                list1.append(1)
            else:
                list1.append(0)
       
    return list1
            

   // Complete the freqQuery function below.
    static List<Integer> freqQuery(List<List<Integer>> queries) {

        List<Integer> q3Results = new ArrayList<>();
        Map<Integer,Integer> intElemFreqMap = new LinkedHashMap<>();

        for (int qIdx = 0 ; qIdx < queries.size() ; qIdx++) {
            assert(queries.get(qIdx).size() == 2);

            int opType = queries.get(qIdx).get(0);
            int opVal = queries.get(qIdx).get(1);
            
            // System.err.println("opType=>" + opType + "<");
            // System.err.println("opVal=>" + opVal + "<");

            switch(opType) {
                case 1:
                    intElemFreqMap.put(opVal, intElemFreqMap.getOrDefault(opVal, 0) + 1);
                    break;
                case 2:
                    if (intElemFreqMap.containsKey(opVal) && intElemFreqMap.get(opVal) >= 1) {
                        intElemFreqMap.put(opVal, intElemFreqMap.get(opVal) - 1);
                    }
                    break;
                case 3:
                    if (intElemFreqMap.containsValue(opVal)) {
                        q3Results.add(1);
                    } else {
                        q3Results.add(0);
                    }
                    break;
                default:
                    System.err.println("Unknown OpType=>" + opType + "<");
            }
        }
        
        return q3Results;
    }

def freqQuery(queries):
    ans = []
    fMap = defaultdict(int)
    cMap = defaultdict(int)
    for op, num in queries:
        if op == 1:
            count = fMap[num] 
            fMap[num] += 1
            cMap[count] -= 1
            cMap[count+1] += 1
        elif op == 2:
            count = fMap[num] 
            if count > 0:
                fMap[num] -= 1
                cMap[count] -= 1
                cMap[count-1] += 1
        else:
            ans.append(int(cMap[num] > 0))
    return ans