use std::fs;
use std::io::{BufWriter, Write};
use std::mem;
struct DSU {
    t: Vec<usize>,
    sz: Vec<usize>,
}

impl DSU {
    fn new(n: usize) -> DSU {
        let sz = vec![1; n + 1];
        let mut t = vec![0; n + 1];
        for i in 1..=n { t[i] = i; }
        DSU { t, sz }
    }
    fn find(&mut self, node: usize) -> usize {
        if self.t[node] == node {
            return node;
        }
        self.t[node] = self.find(self.t[node]);
        self.t[node]
    }
    fn unite(&mut self, x: usize, y: usize) {
        let mut x = self.find(x);
        let mut y = self.find(y);
        if x == y { return; }
        if self.sz[x] < self.sz[y] {
            mem::swap(&mut x, &mut y);
        }
        self.sz[x] += self.sz[y];
        self.t[y] = x;
    }
}

fn main() {

    let file = fs::File::create("disjoint.out").unwrap();
    let mut writer = BufWriter::new(file);

    let input: String = fs::read_to_string("disjoint.in").unwrap();
    let mut tokens = input.split_whitespace();

    let mut next_num = || -> usize {
        tokens.next().unwrap().parse::<usize>().unwrap()
    };

    let n = next_num();
    let m = next_num();

    let mut ds = DSU::new(n);
    for _ in 0..m {
        let (op, x, y) = (next_num(), next_num(), next_num());
        match op {
            1 => ds.unite(x, y),
            2 => {
                match ds.find(x) == ds.find(y) {
                    true => write!(writer, "DA\n").unwrap(),
                    false => write!(writer, "NU\n").unwrap(),
                }
            }
            _ => write!(writer, "Unknown operation\n").unwrap(),
        }
    }

}