#include <bits/stdc++.h>
#define MAXN 200000
using namespace std;
ifstream fin("disjoint.in");
ofstream fout("disjoint.out");

int parent[MAXN], nr_of_childs[MAXN];
int n, m,op, x, y;

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

void unite(int x, int y)
    {



            if (nr_of_childs[x] > nr_of_childs[y])
                parent[y] = x;
            else
                parent[x] = y;

            if(nr_of_childs[x] == nr_of_childs[y])
                nr_of_childs[y]++; // cresc rangul noii multimi daca sunt egale

    }

int main(){
    fin >> n >> m;
    for(int i = 0; i<m;i++){
        fin >> op >> x >> y;
        if(op == 1 and root_of(x) != root_of(y )){    // reunim cele 2 elemente/multimi doar daca radacinile sunt diferite, altfel nu are sens
            unite(root_of(x), root_of(y));
        }
        else{           //  vedem daca apartin de aceasi componenta respectiv sunt in aceasi multime
            if(root_of(x) == root_of(y))
                fout << "DA\n";
            else
                fout << "NU\n";
        }
    }
    fin.close();
    fout.close();
    return 0;
}
// ideea algoritmului este de a interoga de fiecare data radacinile nodurilor date, deoarece asa este mai usor de a le reunii si a nu pierde
// vreun element pe parcurs, deoarece daca eu am un union intre 1 si 2 si intre 1 si 3, iar eu verifica apartenenta lui 2 la 3, aceasta va fi adevarata
// chiar daca nu a existat separat operatia de union intre 2 si 3, acestea apartin de aceasi radacina, automat sunt in aceasi multime.