#include <iostream>
#include <fstream>
using namespace std;

ifstream fin("mergeheaps.in");
ofstream fout("mergeheaps.out");

const int MAXN =  102;
int N, Q;

struct nod {

	int val;
	nod* child, *sibling;
	
	nod(int x);
};

nod::nod(int x) : val(x), child(NULL), sibling(NULL) {}

class pairingheap {
	nod* radacina;

	nod* mergeheaps(nod* n1, nod* n2);
	nod* TwoPassMerge(nod* _nod_);
public:
		pairingheap(): radacina ( NULL ){}
		pairingheap(int valoare);
		pairingheap(nod* _nod_) : radacina(_nod_) {}

		int val_max();
		void mergeheaps(pairingheap H);
		void push(int valoare);
		void eliminate();
		void heap_unification(pairingheap& H);

};

nod::nod(int x) : val(x), child(NULL), sibling(NULL) {}

nod* mergeheaps(nod* n1, nod* n2)
{
	if (n1 == NULL)
	{
		n1 = n2;
		return n1;
	}

	else if (n2 == NULL)
	{
		return n1;
	}

	if (n1->val < n2->val)
		swap(n1, n2);

	n2->sibling = n1->child;
	n1->child = n2;

	return n1;
}

nod* TwoPassMerge(nod* _nod_) {
	if (_nod_->sibling == NULL || _nod_ == NULL)
		return _nod_;

	nod* heap1, * heap2, * next_heap;
	heap1 = _nod_;
	heap2 = _nod_->sibling;
	next_heap = _nod_->sibling->sibling;
	heap1->sibling = heap2->sibling = NULL;
	return mergeheaps(mergeheaps(heap1, heap2), TwoPassMerge(next_heap));

}

pairingheap::pairingheap(int valoare) {
	radacina = new nod(valoare);
}

void mergeheaps(pairingheap H) {
	if (radacina == NULL)
	{
		radacina = H.radacina;
		return;
	}
	if (H.radacina = NULL)
		return;
	if (radacina->val < H.radacina->val)
		swap(radacina, H.radacina);

	H.radacina->sibling = radacina->child;
	radacina->child = H.radacina;
	H.radacina = NULL;
}

void push(int valoare) {
	mergeheaps(pairingheap(valoare));
}

void eliminate() {
	nod* radacina_temp = radacina;
	radacina = TwoPassMerge(radacina->child);
	delete radacina_temp;
}

void heap_unification(pairingheap& H)
{
	mergeheaps(H);
	H.radacina = NULL;
}

int val_max() {
	return radacina->val;
}

pairingheap Heap[MAXN];

int main()
{
	fin >> N >> Q; 

	int cerinta, id_heap, valoare, heap_1, heap_2, i;

	for (i = 0; i < Q; i++)
	{
		fin >> cerinta;
		if (cerinta == 1) {
			fin >> id_heap >> valoare;
			Heap[id_heap].push(valoare);
		}
		if (cerinta == 2) {
			fin >> id_heap;
			fout << Heap[id_heap].val_max() << '\n';
			Heap[id_heap].eliminate();
		}
		if (cerinta == 3) {
			fin >> heap_1 >> heap_2;
			Heap[heap_1].heap_unification(Heap[heap_2]);
		}
	}
	fin.close();
	fout.close();
	return 0;
}