#include <array>
#include <cstdint>
#include <fstream>
#include <numeric>
#include <vector>


/* Defines */
using u32 = uint32_t;
using i32 = int32_t;

template<typename T>
class DisjointForest {
public:
    DisjointForest (const T &nodes): m_jumpback(nodes) {
        std::iota(m_jumpback.begin(), m_jumpback.end(), 0);
    }

    const T& component (const T &node) { return root(node); }

    bool areInSameComponent (const T &lhs, const T &rhs) {
        return component(lhs) == component(rhs);
    }

    void addEdge (const T &from, const T &to) {
        m_jumpback[root(from)] = root(to);
    }
private:
    const T& root (const T &node) {
        if (node != m_jumpback[node])
            m_jumpback[node] = root(m_jumpback[node]);
        return m_jumpback[node];
    }

    std::vector<T> m_jumpback;
};

constexpr const char *inputFilename = "disjoint.in";
constexpr const char *outputFilename = "disjoint.out";


int main () {
    std::ifstream input(inputFilename);
    input.exceptions(input.badbit | input.eofbit | input.failbit);
    std::ofstream output(outputFilename);
    output.exceptions(output.badbit | output.eofbit | output.failbit);

    u32 maxNumber, queries;
    input >> maxNumber >> queries;

    DisjointForest<u32> forest(maxNumber);

    for (u32 i = 0; i != queries; ++ i) {
        u32 type, lhs, rhs;
        input >> type >> lhs >> rhs;
        -- lhs, -- rhs;

        if (type == 1) {
            forest.addEdge(lhs, rhs);
        } else {
            if (forest.areInSameComponent(lhs, rhs)) {
                output << "DA\n";
            } else {
                output << "NU\n";
            }
        }
    }
}