#include <iostream>
#include <vector>
#include <fstream>
#include <algorithm>
#define nmax 100001
using namespace std;

ifstream f("disjoint.in");
ofstream g("disjoint.out");

class Graf{
private:
    vector<vector<int>> la;
    vector<vector<int>> la_t;
    int par[nmax];
    int dim[nmax];
    vector<int> topo;
    bool viz[nmax] = {false};
    int n, m, componente_conexe, dist[nmax] = {-1};
public:
    Graf(): n(0), m(0), componente_conexe(0), dist(){ }
    Graf(int x, int y): n(x), m(y){ }
    Graf(int x, int y, const vector<vector<int>>& v): n(x), m(y), componente_conexe(0), la(v) { }
    void dfs(int nod)
    {
        viz[nod] = true;
        for(auto i : la[nod])
            if(!viz[i])
                dfs(i);
    }

    int nr_componente()
    {
        for(int i = 1; i <= n; i++)
            if(!viz[i]) {
                dfs(i);
                componente_conexe++;
            }
        return componente_conexe;
    }

    void bfs(int nod)
    {
        int c[nmax],p = 0,u = -1;
        c[++u] = nod;
        dist[nod] = 0;
        while(p <= u)
        {
            int x = c[p];
            for(auto i:la[x])
                if(dist[i] == -1)
                {
                    c[++u] = i;
                    dist[i] = dist[x] + 1;
                }
            p++;
        }
    }

    void gol_viz()
    {
        for(int i = 1; i <= n; i++)
            viz[i] = false;
    }
    void ctc(int nr_comp, int comp[], const vector<vector<int>>& ctc)
    {

        gol_viz();
        for(int i = 1; i <= n; i++)
            if(!viz[i])
                sorare_topologica(i);
        reverse(topo.begin(), topo.end());
        for(auto i:topo)
        {
            if(comp[i] == 0)
            {
                nr_comp++;
                gol_viz();
                dfs_t(i, nr_comp, ctc, comp);
            }
        }
    }

    void dfs_t(int nod, int nr_comp, vector<vector<int>> ctc, int comp[])
    {
        viz[nod] = true;
        comp[nod] = nr_comp;
        ctc[nr_comp].push_back(nod);
        for(auto i:la_t[nod])
            if(!viz[i])
                dfs_t(i, nr_comp, ctc, comp);
    }

    void sorare_topologica(int nod)
    {
        viz[nod] = true;
        for(auto i:la[nod])
        {
            if(viz[i] == 0)
                sorare_topologica(i);
        }
        topo.push_back(nod);
    }

    bool hakimi(vector<int> &grade)
    {
        sort(grade.begin(), grade.end(), greater<>());
        while(!grade.empty())
        {
            if(grade[0] + 1 > grade.size())
                return false;
            for(int i = 1; i <= grade[0]; ++i)
            {
                grade[i]--;
                if(grade[i] < 0)
                    return false;
            }
            grade.erase(grade.begin());
            sort(grade.begin(), grade.end(), greater<>());
        }
        return true;
    }
    void init()
    {
        for(int i=1;i <= n;++i) {
            par[i] = i;
            dim[i] = 1;
        }
    }
    int find(int x) {
        while(x != par[x]) {
            x = par[x];
        }
        return x;
    }

    void unite(int x, int y)
    {
       x = find(x);
       y = find(y);
        if(dim[x] >= dim[y])
        {
            par[y] = x;
            dim[x] += dim[y];
        }
        else
        {
            par[y] = x;
            dim[y] += dim[x];
        }
    }
};



int main()
{
    int n, m, x ,y, cod;
    //vector<vector<int>> l;
    f >> n >> m;
    Graf graf(n, m);
    graf.init();
    for(int i = 1; i <= m; i++)
    {
        f >> cod >> x >> y;
        if(cod == 1)
            graf.unite(x, y);
        else if(graf.find(x) == graf.find(y))
            g << "DA" << '\n';
        else g << "NU" << '\n';
    }
    return 0;
}