#include <iostream>
#include <string>
#include <sstream>
using namespace std;

struct calkowita {
	int wartosc;
	int numerRekordu;
	calkowita* lewy_syn;
	calkowita* prawy_syn;
};

struct zmienno {
	float wartosc;
	int numerRekordu;
	zmienno* lewy_syn;
	zmienno* prawy_syn;
};

struct ciag {
	string wartosc;
	int numerRekordu;
	ciag* lewy_syn;
	ciag* prawy_syn;
};
int licznikcalkowita = 0;
int licznikzmienno = 0;
int licznikciag = 0;
calkowita* calkowite = NULL;
zmienno* zmiennoprzecinkowe = NULL;
ciag* ciagi = NULL;
string* wyniki;

template <class par1, class par2>
int znajdz(par1 wezel, par2 klucz) { // false - znaleziono; true - nie znaleziono
	if(wezel == NULL) {
		return 0;
	} else if(wezel->wartosc == klucz) {
		return 1;
	} else if(klucz < wezel->wartosc) {
		return znajdz(wezel->lewy_syn, klucz);
	} else {
		return znajdz(wezel->prawy_syn, klucz);
	}
}

template <class par1, class par2>
par1 znajdzPoKluczu(par1 wezel, par2 klucz) { // false - znaleziono; true - nie znaleziono
	if(wezel == NULL) {
		return NULL;
	} else if(wezel->wartosc == klucz) {
		return wezel;
	} else if(klucz < wezel->wartosc) {
		return znajdzPoKluczu(wezel->lewy_syn, klucz);
	} else {
		return znajdzPoKluczu(wezel->prawy_syn, klucz);
	}
}

int znajdz(ciag* wezel, string klucz) { // false - znaleziono; true - nie znaleziono
	if(wezel == NULL) {
		return 0;
	} else if(wezel->wartosc.compare(klucz) == 0) {
		return 1;
	} else if(klucz.compare(wezel->wartosc) < 0) {
		return znajdz(wezel->lewy_syn, klucz);
	} else {
		return znajdz(wezel->prawy_syn, klucz);
	}
}

ciag* znajdzPoKluczu(ciag* wezel, string klucz) {
	if(wezel == NULL) {
		return NULL;
	} else if(wezel->wartosc.compare(klucz) == 0) {
		return wezel;
	} else if(klucz.compare(wezel->wartosc) < 0) {
		return znajdzPoKluczu(wezel->lewy_syn, klucz);
	} else {
		return znajdzPoKluczu(wezel->prawy_syn, klucz);
	}
}

template <class par1, class par2>
par1 znajdzPoNumerze(par1 wezel, par2 numer) {
	if(wezel->lewy_syn != NULL) return znajdzPoNumerze(wezel->lewy_syn, numer);
	if(wezel->numerRekordu == numer) {
		return wezel;
	}
	if(wezel->prawy_syn != NULL) return znajdzPoNumerze(wezel->prawy_syn, numer);
}

template <class par1, class par2>
void znajdzWartoscPoNumerze(par1 wezel, par2 numer) {
	if(wezel->lewy_syn != NULL) znajdzWartoscPoNumerze(wezel->lewy_syn, numer);
	if(wezel->numerRekordu == numer) {
		cout<<wezel->wartosc<<endl;
	}
	if(wezel->prawy_syn != NULL) znajdzWartoscPoNumerze(wezel->prawy_syn, numer);
}
/*template <class par1, class par2>
par1 znajdzNumer(par1 wezel, par2 numer) {
	if(wezel->lewy_syn != NULL) return znajdzNumer(wezel->lewy_syn, numer);
	if(wezel->wartosc == numer) {
		return wezel;
	}
	if(wezel->prawy_syn != NULL) return znajdzNumer(wezel->prawy_syn, numer);
}*/


void dodaj(calkowita* &wezel, int wartosc) {
	if(wezel == NULL) {
		wezel = new calkowita;
		wezel->wartosc = wartosc;
		wezel->lewy_syn = NULL;
		wezel->prawy_syn = NULL;
		licznikcalkowita++;
		wezel->numerRekordu = licznikcalkowita;
		return;
	} else if(wezel->wartosc == wartosc) {
		return;
	} else if(wartosc < wezel->wartosc) {
		dodaj(wezel->lewy_syn, wartosc);
	} else {
		dodaj(wezel->prawy_syn, wartosc);
	}
}

void dodaj(zmienno* &wezel, float wartosc) {
	if(wezel == NULL) {
		wezel = new zmienno;
		wezel->wartosc = wartosc;
		wezel->lewy_syn = NULL;
		wezel->prawy_syn = NULL;
		licznikzmienno++;
		wezel->numerRekordu = licznikzmienno;
		return;
	} else if(wezel->wartosc == wartosc) {
		return;
	} else if(wartosc < wezel->wartosc) {
		dodaj(wezel->lewy_syn, wartosc);
	} else {
		dodaj(wezel->prawy_syn, wartosc);
	}
}

void dodaj(ciag* &wezel, string wartosc) {
	if(wezel == NULL) {
		wezel = new ciag;
		wezel->wartosc = wartosc;
		wezel->lewy_syn = NULL;
		wezel->prawy_syn = NULL;
		licznikciag++;
		wezel->numerRekordu = licznikciag;
		return;
	} else if(wezel->wartosc.compare(wartosc) == 0) {
		return;
	} else if(wezel->wartosc.compare(wartosc) > 0) {
		dodaj(wezel->lewy_syn, wartosc);
	} else {
		dodaj(wezel->prawy_syn, wartosc);
	}
}

template <class par1, class par2>
bool usun(par1* &wezel, par2 wartosc) { // false - nie ma takiego klucza; true - usunięto
	if(wezel == NULL) {
		return false;
	} else if(wezel->wartosc == wartosc) {
		if(wezel->lewy_syn == NULL && wezel->prawy_syn == NULL) { // węzeł jest liściem
			delete wezel;
		} else if(wezel->lewy_syn != NULL && wezel->prawy_syn == NULL) { // węzeł ma tylko lewego syna
			wezel = wezel->lewy_syn;
			delete wezel->lewy_syn;
		} else if(wezel->prawy_syn != NULL && wezel->lewy_syn == NULL) { // węzeł ma tylko prawego syna
			wezel = wezel->prawy_syn;
			delete wezel->prawy_syn;
		} else { // węzeł ma dwóch synów
			par1 *poprzednik = new par1;
			poprzednik = wezel->lewy_syn;
			while(poprzednik->prawy_syn!=NULL) {
				poprzednik = poprzednik->prawy_syn;
			}
			wezel->wartosc = poprzednik->wartosc;
			usun(poprzednik, poprzednik->wartosc);
		}
	} else if(wartosc < wezel->wartosc) {
		return usun(wezel->lewy_syn, wartosc);
	} else {
		return usun(wezel->prawy_syn, wartosc);
	}
}

/*string przedzial(ciag* wezel, string poczatek, string koniec) { // in order
	ostringstream tmp;

	if(wezel->lewy_syn != NULL) tmp << przedzial(wezel->lewy_syn, poczatek, koniec);
	if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
		zmienno* tmp1;
		calkowita* tmp2;
		tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, wezel->numerRekordu);
		tmp2 = znajdzPoNumerze(calkowite, wezel->numerRekordu);

		tmp<<tmp2->wartosc<<endl;
		tmp<<tmp1->wartosc<<endl;
		tmp<<wezel->wartosc<<endl;
	}
	if(wezel->prawy_syn != NULL) tmp << przedzial(wezel->prawy_syn, poczatek, koniec);
	return tmp.str();
}*/

void przedzial(calkowita* wezel, int poczatek, int koniec) { // in order
	if(wezel->lewy_syn != NULL)  przedzial(wezel->lewy_syn, poczatek, koniec);
	if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
		znajdzWartoscPoNumerze(zmiennoprzecinkowe, wezel->numerRekordu);
		znajdzWartoscPoNumerze(calkowite, wezel->numerRekordu);
		znajdzWartoscPoNumerze(ciagi, wezel->numerRekordu);
	}
	if(wezel->prawy_syn != NULL)  przedzial(wezel->prawy_syn, poczatek, koniec);
}

template <class par1, class par2, class par3>
void dupa(par1 wezel, par2 poczatek, par3 koniec) {
	ciag* tmp3 = new ciag;
	ostringstream tmp;
	if(wezel->lewy_syn != NULL) dupa(wezel->lewy_syn, poczatek, koniec);
	if(wezel->wartosc >= poczatek && wezel->wartosc <= koniec) {
		cout<<wezel->wartosc<<" "<<wezel->numerRekordu<<endl;
	}
	if(wezel->prawy_syn != NULL) dupa(wezel->prawy_syn, poczatek, koniec);
}

void wstaw() {
	int a;
	float b;
	string c;
	cin>>a>>b>>c;
	dodaj(calkowite, a);
	dodaj(zmiennoprzecinkowe, b);
	dodaj(ciagi, c);
}
void usunRekord() {
	int a;
	cin>>a;
	if(a == 0) {
		int dousuniecia;
		cin>>dousuniecia;
		zmienno* tmp1;
		calkowita* tmp2;
		ciag* tmp3;
		tmp2 = znajdzPoKluczu(calkowite, dousuniecia);
		tmp1 = znajdzPoNumerze(zmiennoprzecinkowe, tmp2->numerRekordu);
		tmp3 = znajdzPoNumerze(ciagi, tmp2->numerRekordu);
		cout<<"Chce usunac calkowita "<<tmp2->wartosc<<endl;
		cout<<"Chce usunac zmiennoprzecinkowa "<<tmp1->wartosc<<endl;
		cout<<"Chce usunac ciag "<<tmp3->wartosc<<endl;
		usun(calkowite, dousuniecia);
		usun(zmiennoprzecinkowe, tmp1->wartosc);
		usun(ciagi, tmp3->wartosc);
	} else if(a == 1) {
		float dousuniecia;
		cin>>dousuniecia;
		usun(zmiennoprzecinkowe, dousuniecia);
	} else {
		string dousuniecia;
		cin>>dousuniecia;
		usun(ciagi, dousuniecia);
	}
}
void znajdzRekord() {
	int a;
	cin>>a;
	if(a == 0) {
		int wyszukiwana;
		cin>>wyszukiwana;
		cout<<znajdz(calkowite, wyszukiwana);
	} else if(a == 1) {
		float wyszukiwana;
		cin>>wyszukiwana;
		cout<<znajdz(zmiennoprzecinkowe, wyszukiwana);
	} else {
		string wyszukiwana;
		cin>>wyszukiwana;
		cout<<znajdz(ciagi, wyszukiwana);
	}
}
int main() {
	int n;
	cin>>n;
	wyniki = new string[n];
	for(int i=0;i<n;i++) {
		int m;
		cin>>m;
		calkowita* calkowite = new calkowita;
		zmienno* zmiennoprzecinkowe = new zmienno;
		ciag* ciagi = new ciag;

		for(int j=0;j<m;j++) {
			int x;
			cin>>x;
			switch(x) {
				case 1: wstaw();
				break;
				case 2: usunRekord();
				break;
				case 3: znajdzRekord();
				break;
			}
		}
	}
	/*calkowita* calkowite = new calkowita;
	zmienno* zmiennoprzecinkowe = new zmienno;
	ciag* ciagi = new ciag;

	dodaj(calkowite, 5);
	dodaj(calkowite, 8);

	calkowita* tmp  = znajdzNumer(calkowite, 1);
	cout<<tmp->wartosc<<endl;
	*/

	przedzial(calkowite, 1, 100);
	cout<<endl<<endl;
	przedzial(ciagi, "a", "zzzz");
	/*
	calkowita* element = new calkowita;
	element = znajdzNumer(calkowite, 1);
	cout<<"Test: "<<element->wartosc<<endl;
	for(int i=0;i<n;i++) {
		cout<<wyniki[i]<<endl;
	}*/
	/*cout<<endl<<endl;
	string test;
	dupa(ciagi, "a", "z");
	ciag* testowy = new ciag;
	testowy = znajdzNumer(ciagi, 2);
	cout<<testowy->wartosc<<endl;
	test = przedzial(calkowite, 1, 1000);
	cout<<test<<endl;
	*/
return 0;
}