//Disjoint Sets using union by rank and path compression Graph Algorithm

#include <iostream>
#include <fstream>
using namespace std;
ifstream f("disjoint.in");
ofstream g("disjoint.out");
int N, M;
int* tata;
int* h;

int findSet(int nod)
{
    //daca nodul nu are tata/tata[nod]=0 atunci ne aflam in radacina
    if(tata[nod] == nod) {
        return nod;
    }
    //pornim pe drumul nodului curent pana ajungem la radacina
    //astfel ne putem scurta drumul si formam o legatura directa dintre...
    //...nodul de la care am pornit pana la radacina arborelui din care face parte
    //TODO: path compression
    return tata[nod] = findSet(tata[nod]);

}

void Union(int x, int y) {

    int tata_x = findSet(x);
    int tata_y = findSet(y);

    //Cand facem union by rank trebuie sa comparam inaltimea...
    //...arborilor cu radacinile tata_x respectiv tata_y
    //radacina arborelui care are inaltimea mai mare va deveni...
    //...radacina grafului format prin reuniune
    if(h[tata_x] > h[tata_y]) {
        tata[tata_y] = tata_x;
    } else if(h[tata_x] < h[tata_y]) {
        tata[tata_x] = tata_y;
    } else {
        //regula spune ca daca inaltimile sunt egale atunci...
        //...nu conteaza cine este radacina
        //trebuie sa si crestem inaltimea radacinii cu 1 in acest caz
        tata[tata_y] = tata_x;
        h[tata_x]++;
    }
}
int main()
{
    f>>N>>M;

    tata = new int[N+1];
    h = new int[N+1];
    //initializam vectorul de tati a.i. la inceput fiecare nod are radacina in el insusi
    //vectorul de adancime il initializam cu 0
    for(int i = 0; i<= N; i++) {
        tata[i] = i;
        h[i] = 0;
    }

    for(int i = 1; i <= M; i++) {
        int cod, x, y;
        f>> cod >> x >> y;
        if(cod == 1) {
            Union(x, y);
        }
        else if(cod == 2) {
            if (findSet(x) == findSet(y))
                g<<"DA\n";
            else
                g<<"NU\n";
        }
    }

    return 0;
}