#include <bits/stdc++.h>

using namespace std;

namespace TreapOps {
    const int kMaxNodes = 500000;
    
    struct TreapNode {
        TreapNode *l, *r, *parent;
        int priority;
    };
    typedef TreapNode* TreapIter;
    TreapNode buff[kMaxNodes];
    TreapIter nill = buff;
    int nodes;
    
    void Init() {
        nill->l = nill->r = nill->parent = nill;
        nill->priority = -1;
    }
    
    TreapIter CreateSingleton() {
        TreapIter ret = buff + (++nodes);
        ret->l = ret->r = ret->parent = nill;
        ret->priority = rand();
        return ret;
    }
    void Refresh(TreapIter it) {
        if(it == nill) return;
        if(it->l != nill) it->l->parent = it;
        if(it->r != nill) it->r->parent = it;
    }
    TreapIter Join(TreapIter l, TreapIter r) {
        if(l == nill) return r;
        if(r == nill) return l;
        
        TreapIter ret = nill;
        if(l->priority > r->priority) {
            l->r = Join(l->r, r);
            ret = l;
        } else {
            r->l = Join(l, r->l);
            ret = r;
        }
        Refresh(ret);
        return ret;
    }
    TreapIter GetRoot(TreapIter it) {
        while(it->parent != nill)
            it = it->parent;
        return it;
    }
};
using namespace TreapOps;

int main() {
    freopen("disjoint.in", "r", stdin);
    freopen("disjoint.out", "w", stdout);
    
    srand(time(0));
    int n, m;
    cin >> n >> m;
    
    Init();
    vector<TreapIter> V(n);
    for(int i = 0; i < n; ++i)
        V[i] = CreateSingleton();
        
    while(m--) {
        int op, a, b;
        cin >> op >> a >> b;
        
        auto it1 = GetRoot(V[a - 1]);
        auto it2 = GetRoot(V[b - 1]);
        
        if(op == 1) {
            if(it1 != it2) 
                Join(it1, it2);
        } else {
            cout << ((it1 == it2) ? "DA\n" : "NU\n");
        }
    }
    
    return 0;
}