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

ifstream in("mergeheap.in");
ofstream out("mergeheap.out");

class PairNode
{
public:
    int val;
    PairNode *copilSt;
    PairNode *frateUrm;
    PairNode *ant;

    PairNode(int val)
    {
        this->val = val;
        copilSt = NULL;
        frateUrm = NULL;
        ant = NULL;
    }

    void adauga(PairNode *n)
    {
        if(copilSt == NULL)
            copilSt = n;
          else {
            n->frateUrm = copilSt;
            copilSt = n;
          }
    }
};

PairNode *combina(PairNode *h1, PairNode *h2)
{
    if(h1 == NULL) return h2;
    if(h2 == NULL) return h1;

    if(h1->val < h2->val) {
        h1->adauga(h2);
        return h1;
     }
        else {
            h2->adauga(h1);
            return h2;
        }

    return NULL;
}

PairNode *combina_rec(PairNode *n) {
    if(n == NULL || n->frateUrm == NULL)
        return n;
      else {
        PairNode *h1, *h2, *nod_nou;

        h1 = n;
        h2 = n->frateUrm;
        nod_nou = n->frateUrm->frateUrm;
        h1->frateUrm = NULL;
        h2->frateUrm = NULL;

        return combina(combina(h1, h2), combina_rec(nod_nou));
      }
    return NULL;
}

PairNode *sterge(PairNode *n) {
    return combina_rec(n->copilSt);
}

class PairingHeap{
private:
    PairNode *rad;
public:
    PairingHeap()
    {
        rad = NULL;
    }

    PairingHeap(int x)
    {
        rad = new PairNode(x);
    }

    ~PairingHeap()
    {
        refresh(rad);
        rad = NULL;
    }

    void refresh(PairNode *aux)
    {
        if (aux != NULL) {
            refresh(aux->copilSt);
            refresh(aux->frateUrm);

            delete aux;
        }
    }

    bool Vid()
    {
        return rad == NULL;
    }

    void join(PairingHeap& heap2)
    {
        if(this->rad == NULL)
            this->rad = heap2.rad;
         else if(this->rad->val > heap2.rad->val) {
            if(this->rad->copilSt != NULL)
                this->rad->copilSt->ant = heap2.rad;

            heap2.rad->frateUrm = this->rad->copilSt;
            this->rad->copilSt = heap2.rad;
          }
           else {
                if(heap2.rad->copilSt != NULL)
                    heap2.rad->copilSt->ant = this->rad;

                this->rad->frateUrm = heap2.rad->copilSt;
                heap2.rad->copilSt = this->rad;
                this->rad = heap2.rad;
           }
        heap2.rad = NULL;
    }

    void inserare(int x)
    {
        PairingHeap temp(x);
        this->join(temp);
    }

    int &minim()
    {
        return rad->val;
    }

    void sterge(void) {
        rad = ::sterge(rad);
    }
};


int main()
{
    int minim, op, ind, ind2, val, nr_heap, nr_op;

    in>>nr_heap>>nr_op;

    PairingHeap pheap[nr_heap+1];

    while(nr_op)
    {
        in>>op;
        ///cout<<op<<"\n";
        switch(op)
        {
            case 1:
                in>>ind>>val;
                pheap[ind].inserare(val);
                break;
            case 2:
                in>>ind;
                out<<pheap[ind].minim()<<"\n";
                pheap[ind].sterge();
                break;
            case 3:
                in>>ind>>ind2;
                pheap[ind].join(pheap[ind2]);
                break;
            default:
                break;
        }
        nr_op--;
    }
    return 0;
}