#include <stdio.h>
#include <algorithm>
//#include <string>

class InParser {
private :
    FILE *fin;
    char *buf;
    const int lim = 1 << 16;
    int pos;

    inline void next() {
        if(++pos == lim){
            fread(buf, 1, lim, fin);
            pos = 0;
        }
    }
public :
    InParser (const char *file_name){
        fin = fopen(file_name, "r");
        pos = lim - 1;
        buf = new char[lim]();
    }

    InParser& operator >> (char &x){
        x = buf[pos];
        next();
        return *this;
    }

    InParser& operator >> (char *x) {
        for(int i = 0; buf[pos] > 32; i++, next()) {
            x[i] = buf[pos];
        }
        return *this;
    }

//    InParser& operator >> (std :: string &x) {
//        x = "";
//        for(; buf[pos] < ' '; next());
//        for(; buf[pos] > ' '; next()) {
//            x.push_back(buf[pos]);
//        }
//        x[x.size()] = '\0';
//        return *this;
//    }

    InParser& operator >> (int &x){
        x = 0;
        int sgn = 1;

        for(; buf[pos] < '0' || buf[pos] > '9'; next()){
            if(buf[pos]=='-'){
                sgn = -1;
            }
        }

        for(; buf[pos] >= '0' && buf[pos] <= '9'; next()){
            x = x * 10 + buf[pos] - '0';
        }

        x *= sgn;
        return *this;
    }

    InParser& operator >> (long long &x){
        x = 0;
        int sgn = 1;

        for(; buf[pos] < '0' || buf[pos] > '9'; next()){
            if(buf[pos]=='-'){
                sgn = -1;
            }
        }

        for(; buf[pos] >= '0' && buf[pos] <= '9'; next()){
            x = x * 10 + buf[pos] - '0';
        }

        x *= sgn;
        return *this;
    }
};

class OutParser {
private :
    FILE *fout;
    char *buf;
    const int lim = 1 << 16;
    int pos;

    inline void put_ch(const char ch) {
        if (pos == lim) {
            fwrite(buf, 1, lim, fout);
            pos = 0;
            buf[pos++] = ch;
        } else {
            buf[pos++] = ch;
        }
    }
public :
    OutParser (const char *file_name){
        fout = fopen(file_name, "w");
        pos = 0;
        buf = new char[lim]();
    }

    ~OutParser() {
        fwrite(buf, 1, pos, fout);
    }

    OutParser& operator << (int x){
        if(x < 0) {
            put_ch('-');
            x = -x;
        }
        if(x == 0) {
            put_ch('0');
            return *this;
        }
        int i;
        for(i = 1; i <= x; i *= 10);
        i /= 10;
        for(; i > 0; i /= 10) {
            put_ch((char)(x / i + '0'));
            x %= i;
        }
        return *this;
    }

    OutParser& operator << (char x){
        put_ch(x);
        return *this;
    }

    OutParser& operator << (const char *x){
        for(int i = 0; x[i]; i++) {
            put_ch(x[i]);
        }
        return *this;
    }
//    OutParser& operator << (const std :: string &x){
//        for(int i = 0; i < x[i]; i++) {
//            put_ch(x[i]);
//        }
//        return *this;
//    }
};

InParser fin("disjoint.in");
OutParser fout("disjoint.out");

const int NMAX = 1e5;

int M;
int crt_max, N;
int parent[NMAX + 1];
int set_size[NMAX + 1];

void make_set(int node) {
    parent[node] = node;
    set_size[node] = 1;
}

int find_set(int node) {
    if(parent[node] == node) {
        return node;
    }
    return node = find_set(parent[node]);
}

void union_set(int node1, int node2) {
    int set1 = find_set(node1);
    int set2 = find_set(node2);

    if(set1 != set2) {
        if(set_size[set1] < set_size[set2]) {
            parent[set1] = set2;
            set_size[set2] += set_size[set1];
            crt_max = std :: max(crt_max, set_size[set2]);
        } else {
            parent[set2] = set1;
            set_size[set1] += set_size[set2];
            crt_max = std :: max(crt_max, set_size[set1]);
        }
    }
}

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

    for(int i = 1; i <= N; i++) {
        make_set(i);
    }

    while(M--) {
        int op, x, y;
        fin >> op >> x >> y;

        if(op == 1) {
            union_set(x, y);
        } else if(op == 2) {
            if(find_set(x) == find_set(y)) {
                fout << "DA\n";
            } else {
                fout << "NU\n";
            }
        }
    }
    return 0;
}