/// Acest algoritm asigură căutări în timp constant.


//#define fisier "disjoint"


#ifdef fisier
    #include <fstream>
    std::ifstream in(fisier ".in");
    std::ofstream out(fisier ".out");
#else
    #include <iostream>
    #define in std::cin
    #define out std::cout
#endif



const int
N = 100000,
M = N;

int n;

#include <vector>
struct Varf
{
    Varf* tata;
    std::vector<Varf*> copii;

    void schimba_tata(Varf* nou_tata) // Poate fi O(n) în cazul cel mai nefavorabil, dar să vedem în practică.
    {
        copii.push_back(this);
        for (auto copil: copii)
        {
            nou_tata->copii.push_back(copil);
            copil->tata = nou_tata;
        }
        copii.clear();
    }

    Varf* radacina() // Timp constant.
    {
        if (tata)
            return tata;
        return this;
    }
}
*graf;

inline Varf* radacina(int element)
{
    return graf[element].radacina();
}

inline void uneste(int a, int b)
{
    radacina(a)->schimba_tata(radacina(b));
}



int main()
{
    int m;
    in >> n >> m;
    graf = new Varf[n]();

    while (m--)
    {
        int op, a, b;
        in >> op >> a >> b;
        a--, b--;

        if (op & 1)
            uneste(a, b);
        else
            out << (radacina(a) == radacina(b)? "DA": "NU") << '\n';
    }

    delete[] graf;
}