#include <fstream>
using namespace std;
ifstream f("mergeheap.in");
ofstream g("mergeheap.out");

class Node
{
public:
    Node* child;
    int val;
    Node* bro;
    Node(int valoare):val(valoare),child(nullptr),bro(nullptr){}
    Node(Node* nod)
    {
        val=nod->val;
        child=nod->child;
        bro=nod->bro;
    }
    int getData() const
    {
        return val;
    }
};
class PairingHeap
{
private:
    Node* radacina;
public:
    PairingHeap() : radacina(nullptr) {}

    ~PairingHeap() {
        delete(radacina);
    }
    //pentru cerinta 1
    void insert(const int& value)
    {
        if(radacina==nullptr)
        {
            radacina = new Node(value);
            return;
        }
        Node* aux = new Node(value);
        if(radacina->getData() < value)
            swap(radacina, aux);
        aux->bro=radacina->child;
        radacina->child=aux;
    }
    //cerinta 2
    int getMaxim()
    {
        int maxim = radacina->getData();
        Node* oldroot = radacina;
        if(radacina->child== nullptr)
            radacina = nullptr;
        else radacina = mergePairs(radacina->child);
        delete oldroot;
        return maxim;
    }
    //cerinta 3
    void merge(PairingHeap& other)
    {
        if(other.radacina == nullptr)return;
        if(radacina == nullptr){
            swap(radacina,other.radacina);
            return;
        }
        if(other.radacina->getData()>radacina->getData()){
            swap(radacina,other.radacina);
        }
        other.radacina->bro=radacina->child;
        radacina->child=other.radacina;
        other.radacina = nullptr;
    }
    //cerinta 2
    Node* mergePairs(Node* first) {
        if (first == nullptr || first->bro == nullptr)
            return first;
        Node* second = first->bro;
        Node* rest = second->bro;

        first->bro = nullptr;
        second->bro = nullptr;
        first=mergePairs(second);
        first=mergePairs(rest);
        Node* merged=mergePairs(first);
        return merged;
    }

};

int main()
{
    int N, Q;
    f >> N >> Q;
    PairingHeap heap[N];
    for (int i = 0; i < Q; i++)
    {
        int op, m, x, y;
        f >> op;
        switch (op)
        {
            case 1:
                f >> m >> x;
                heap[m].insert(x);
                break;

            case 2:
                f >> m;
                g << heap[m].getMaxim()<<"\n";
                break;

            case 3:
                f >> x >> y;
                heap[x].merge(heap[y]);
                break;
        }
    }
    return 0;
}