import static java.lang.Character.isDigit;
import static java.util.Objects.requireNonNull;

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public final class Main {
  public static final String IN_FILE = "disjoint.in";
  public static final String OUT_FILE = "disjoint.out";

  public static final class FastScanner implements AutoCloseable {
    private static final int BUFFER_SIZE = 1 << 16;

    private final DataInputStream stream;
    private final byte[] buffer = new byte[BUFFER_SIZE];
    private int bufferPointer = 0;
    private int bytesRead = 0;

    public FastScanner(final String fileName) throws IOException {
      stream = new DataInputStream(new FileInputStream(fileName));
    }

    public int nextInt() throws IOException {
      byte c;
      do {
        c = read();
      } while (c != '-' && !isDigit(c));
      final boolean isNegative = c == '-';
      if (isNegative) {
        c = read();
      }
      int value = 0;
      do {
        value = value * 10 + (c - '0');
        c = read();
      } while (isDigit(c));
      return isNegative ? -value : value;
    }

    private byte read() throws IOException {
      final byte c = tryRead();
      if (c == -1) {
        throw new IOException("Reached end of stream!");
      }
      return c;
    }

    private byte tryRead() throws IOException {
      if (bufferPointer == bytesRead) {
        bufferPointer = 0;
        bytesRead = stream.read(buffer, 0, BUFFER_SIZE);
        if (bytesRead == -1) {
          bytesRead = 0;
          return -1;
        }
      }
      return buffer[bufferPointer++];
    }

    @Override
    public void close() throws IOException {
      stream.close();
    }
  }

  public static final class DisjointSets {
    private static final int NIL = -1;

    private final int size;
    private final int[] parent;

    public DisjointSets(final int size) {
      this.size = size;
      this.parent = new int[size];
      Arrays.fill(this.parent, NIL);
    }

    public int find(final int x) {
      if (parent[x] == NIL) {
        return x;
      }
      parent[x] = find(parent[x]);
      return parent[x];
    }

    public boolean merge(final int x, final int y) {
      final int rx = find(x);
      final int ry = find(y);
      if (rx == ry) {
        return false;
      }
      parent[ry] = rx;
      return true;
    }
  }

  public static void main(final String[] args) throws IOException {
    try (final FastScanner scanner = new FastScanner(IN_FILE);
        final PrintWriter writer = new PrintWriter(OUT_FILE)) {
      final int n = scanner.nextInt();
      final int m = scanner.nextInt();
      final DisjointSets sets = new DisjointSets(n);
      for (int i = 1; i <= m; i++) {
        final int type = scanner.nextInt();
        final int x = scanner.nextInt() - 1;
        final int y = scanner.nextInt() - 1;
        if (type == 1) {
          sets.merge(x, y);
        } else {
          writer.println(sets.find(x) == sets.find(y) ? "DA" : "NU");
        }
      }
    }
  }
}