#include <iostream>
#include <fstream>
#include <list>

using namespace std;

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

struct Node {
    int val;
    list<Node*> children;
};

class PairingHeap {
private:
    Node* root;

    Node* mergePairs(list<Node*>& heapList) {
        if (heapList.empty()) return nullptr;

        auto it = heapList.begin();
        Node* first = *it;
        it = heapList.erase(it);

        if (it != heapList.end()) {
            Node* second = *it;
            heapList.erase(it);
            return merge(merge(first, second), mergePairs(heapList));
        }
        else {
            return first;
        }
    }

    Node* merge(Node* a, Node* b) {
        if (!a) return b;
        if (!b) return a;

        if (a->val < b->val) {
            a->children.push_back(b);
            return a;
        }
        else {
            b->children.push_back(a);
            return b;
        }
    }

public:
    PairingHeap() : root(nullptr) {}

    void insert(int x) {
        Node* newNode = new Node({x, {}});
        root = merge(root, newNode);
    }

    int findMin() {
        if (!root) throw runtime_error("Heap is empty");
        return root->val;
    }

    int deleteMin() {
    if (!root) throw runtime_error("Heap is empty");

    int minVal = root->val;
    list<Node*> newHeapList;
    for (auto child : root->children) {
        newHeapList.push_back(child);
    }
    delete root;
    root = mergePairs(newHeapList);

    return minVal;
}


    void meld(PairingHeap& otherHeap) {
        root = merge(root, otherHeap.root);
        otherHeap.root = nullptr;
    }
};

int N, M;
PairingHeap Heap[101];

int main() {
    f >> N >> M;

    int opt, heap, x, heap1, heap2;
    for (int i = 1; i <= M; ++i) {
        f >> opt;

        if (opt == 1) {                        //insert 
            f >> heap >> x;
            Heap[heap].insert(x);
        }
        if (opt == 2) {                        //delete min + afis
            f >> heap;
            g << Heap[heap].findMin() << '\n';
            Heap[heap].deleteMin();
        }
        if (opt == 3) {                       //merge 
            f >> heap1 >> heap2;
            Heap[heap1].meld(Heap[heap2]);
        }
    }
    return 0;
}