#include <bits/stdc++.h>

using namespace std;


class DisjointSet {
    // unordered_set <int> parents;
    // unordered_map<int, int> parent;
    // unordered_map<int, int> size;
    // unordered_map<int, int> rank;

    vector<int> parent;
    vector<int> size;
    vector<int> rank;

public:
    DisjointSet(int max_value) {
        parent.resize(max_value + 1, 0);
        size.resize(max_value + 1, 1);
        rank.resize(max_value + 1, 0);
    }

    int find(int v) {
        if (parent[v] == 0) {
            return v;
        }

        // path compression
        parent[v] = find(parent[v]);

        return parent[v];
    }

    // void add(int v) {
    //     if (parent.find(v) != parent.end()) {
    //         return;  // element already exists
    //     }

    //     parent[v] = v;
    //     parents.insert(v);
    //     size[v] = 1;
    //     rank[v] = 1;
    // }

    void unite(int u, int v) {
        u = find(u);
        v = find(v);

        if (rank[u] < rank[v]) {
            parent[u] = v;
            size[v] += size[u];
            // parents.erase(u);
        } else if (rank[v] < rank[u]) {
            parent[v] = u;
            size[u] += size[v];
            // parents.erase(v);
        } else {
            parent[u] = v;
            size[v] += size[u];
            // parents.erase(u);
            rank[v]++;
        }
    }
};


int main() {
    #ifndef ONLINE_JUDGE
        freopen("disjoint.in", "r", stdin);
        freopen("disjoint.out", "w", stdout);
    #endif

    int n, m;
    DisjointSet dj_set(n);

    cin >> n >> m;

    // for (int i = 1; i <= n; ++i) {
    //     dj_set.add(i);
    // }

    int op_type, x, y;
    while(m--) {
        cin >> op_type >> x >> y;
        if (op_type == 1) {
            dj_set.unite(x, y);
        } else {
            cout << (dj_set.find(x) == dj_set.find(y) ? "DA\n" : "NU\n");
        }
    }

    return 0;
}