use std::fs;
use std::io::{BufWriter, Write};

struct DSU {
    t: Vec<usize>,
}

impl DSU {
    fn new(n: usize) -> DSU {
        let mut v = vec![0; n + 1];
        for i in 1..=n { v[i] = i; }
        DSU { t: v }
    }
    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 x = self.find(x);
        self.t[x] = self.find(y);
    }
}

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(),
        }
    }

}