#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>

using namespace std;

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

const int nmax = 100001;
const int inf = (1<<30);

class Graf
{
private:
    bool orientat;
    int nrNoduri;
    vector <int> listaAdiacenta[nmax];
    vector <pair <int, int>> listaAdiacentaCost[nmax];
public:
    Graf(int nrNoduri = 0, bool orientat = false);
    void adaugaMuchieCost(int, int, int);
    void citireMuchii(int);
    void citireMuchiiCost(int);
    vector<int> BFS(int);
    void DFS(int, bool*);
    int nrComponenteConexe();
    void DFSStiva(int nodcurent, bool *, stack<int> &);
    void sortareTopologica();
    void TarjanCTC(int&, int, int*, int*, bool*, stack <int> &, vector<vector<int>> &);
    void CTC();
    void TarjanBC(int&, int, int, int*, int*, stack <int>&, vector<vector<int>>&);
    void BC();
    void TarjanMC(int&, int, int, int*, int*, vector<pair<int,int>>&);
    void MC();
    vector <int> citireHakimi();
    bool Hakimi(vector <int>);
    vector <int> Dijkstra(int);
    pair<int, vector <pair <int, int>>> Prim(int);
    vector <int> BellmanFord(int);
    void reuniune(int, int, vector<int>&, vector<int>&);
    int gasire(int, vector<int>&);
    void verifica(int, int, vector<int>&);
    void paduri();
};

Graf :: Graf(int nrNoduri, bool orientat) : nrNoduri(nrNoduri), orientat(orientat)
{
    this->nrNoduri = nrNoduri;
    this->orientat = orientat;
}

void Graf::reuniune(int nod1i, int nod2i, vector <int> &parinte, vector <int> &rang)
{
    int nod1 = gasire(nod1i,parinte);
    int nod2 = gasire(nod2i, parinte);
    if(rang[nod1] > rang[nod2])
    {
        parinte[nod1] = nod2;
    }
    else if(rang[nod2] <rang[nod1])
    {
        parinte[nod2] = nod1;
    }
    else
    {
        parinte[nod2] = nod1;
        rang[nod1]++;
    }
}

int Graf::gasire(int nod, vector <int> &parinte)
{
    if(parinte[nod] == -1)
    {
        return nod;
    }
    parinte[nod] = gasire(parinte[nod], parinte);
    return parinte[nod];
}

void Graf::verifica(int nod1, int nod2, vector<int>&parinte)
{
    if(gasire(nod1,parinte) == gasire(nod2, parinte))
    {
        out << "DA\n";
        return;
    }
    out << "NU\n";
}

void Graf::paduri()
{
    int n, m;
    in >> n >> m;
    int nod1, nod2, operatie;
    vector <int> parinte(nmax, -1);
    vector <int> rang(nmax, 0);
    for(int i = 0 ; i < m ; i++)
    {
        in >> operatie >> nod1 >> nod2;
        if(operatie == 1)
        {
            reuniune(nod1, nod2, parinte, rang);
        }
        else if(operatie == 2)
        {
            verifica(nod1, nod2, parinte);
        }
    }
}

int main()
{
    Graf g(1,true);
    g.paduri();
    return 0;
}