#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <cassert>

using namespace std;

mt19937 Rand(16092002);
mt19937_64 BigRand(16092002);

typedef long long ll;

const int block_sz = 2048; //maybe not optimal
const int arr_sz = 2048;
const int N = 5e5 + 7;
const int M = 1e6 + 7;

vector <int> prank[N];
int pr[N];
int sz[N];

struct quer
{
    int type, a, b, c, d, ind;
};

struct data
{
    vector <int> arr;
    vector <int> cnt;
    data()
    {
        arr.clear();
        cnt.clear();
    }
    void add(int x)
    {
        bool good = false;
        for (int i = 0; i < (int) arr.size(); i++)
        {
            if (arr[i] == x)
            {
                cnt[i]++;
                good = true;
                break;
            }
        }
        if (!good)
        {
            arr.push_back(x);
            cnt.push_back(1);
        }
    }
    void del(int x)
    {
        bool good = false;
        for (int i = 0; i < (int) arr.size(); i++)
        {
            if (arr[i] == x)
            {
                cnt[i]--;
                if (cnt[i] == 0)
                {
                    arr.erase(arr.begin() + i);
                    cnt.erase(cnt.begin() + i);
                }
                break;
            }
        }
    }
    void clear()
    {
        arr.clear();
        cnt.clear();
    }
};

data block[M], ind[M];

vector <quer> add[M], del[M], pt[M];

bool operator < (const quer &a, const quer &b)
{
    if (a.a != b.a)
    {
        return a.a < b.a;
    }
    else
    {
        return a.b < b.b;
    }
}

int get(int v)
{
    if (v == pr[v])
    {
        return v;
    }
    else
    {
        return pr[v] = get(pr[v]);
    }
}

void uni(int u, int v)
{
    u = get(u), v = get(v);
    if (u == v)
    {
        return;
    }
    if (sz[u] > sz[v])
    {
        swap(u, v);
    }
    pr[u] = v;
    sz[v] += sz[u];
}

int main()
{
#ifdef ONPC
    freopen("a.in", "r", stdin);
#endif
    int q, r;
    scanf("%d%d", &q, &r);
    for (int i = 0; i < q; i++)
    {
        pr[i] = i;
    }
    vector <quer> e;
    for (int i = 0; i < q; i++)
    {
        char c;
        scanf(" %c", &c);
        if (c == '+')
        {
            int x, y;
            scanf("%d%d", &x, &y);
            x += (int) 2e5;
            //x - r, y => x - r - y, x - r + y
            //x + r, y => x + r - y, x + r + y
            //x, y - r => x - y + r, x + y - r
            //x, y + r => x - y - r, x + y + r
            //x1, x2, y1, y2
            e.push_back({1, x - y - r, x - y + r, x + y - r, x + y + r, i});
        }
        else
        {
            int i, j;
            scanf("%d%d", &i, &j);
            i--, j--;
            e.push_back({2, i, j, i, j});
        }
    }
    auto f = e;
    for (int i = 0; i < q; i += block_sz)
    {
        for (int i = 0; i < N; i++)
        {
            add[i].clear();
            del[i].clear();
            pt[i].clear();
            block[i].clear();
            ind[i].clear();
        }
        int j = min(q, i + block_sz);
        for (int k = 0; k < i; k++)
        {
            if (e[k].type == 1)
            {
                add[max(0, e[k].a - 2 * r)].push_back(e[k]);
                del[e[k].b + 1].push_back(e[k]);
            }
        }
        for (int k = i; k < j; k++)
        {
            if (e[k].type == 1)
            {
                pt[e[k].a].push_back(e[k]);
            }
        }
        for (int i = 0; i < N; i++)
        {
            for (auto c : del[i])
            {
                block[c.c / arr_sz].del(get(c.ind));
                ind[c.c].del(get(c.ind));
            }
            for (auto c : add[i])
            {
                block[c.c / arr_sz].add(get(c.ind));
                ind[c.c].add(get(c.ind));
            }
            for (auto c : pt[i])
            {
                int vl = max(0, c.c - 2 * r), vr = c.d, res = c.ind;
                int a = vl / arr_sz, b = vr / arr_sz;
                if (a == b)
                {
                    for (int i = vl; i <= vr; i++)
                    {
                        for (auto c : ind[i].arr)
                        {
                            prank[res].push_back(c);
                        }
                    }
                }
                else
                {
                    for (int i = vl; i < (a + 1) * arr_sz; i++)
                    {
                        for (auto c : ind[i].arr)
                        {
                            prank[res].push_back(c);
                        }
                    }
                    for (int i = a + 1; i < b; i++)
                    {
                        for (auto c : block[i].arr)
                        {
                            prank[res].push_back(c);
                        }
                    }
                    for (int i = b * arr_sz; i <= vr; i++)
                    {
                        for (auto c : ind[i].arr)
                        {
                            prank[res].push_back(c);
                        }
                    }
                }
            }
        }
        for (int k = i; k < j; k++)
        {
            if (e[k].type == 1)
            {
                for (int r = i; r < k; r++)
                {
                    if (e[r].type == 1)
                    {
                        if (max(e[r].a, e[k].a) <= min(e[r].b, e[k].b) && max(e[r].c, e[k].c) <= min(e[r].d, e[k].d))
                        {
                            uni(k, r);
                        }
                    }
                }
                for (auto c : prank[k])
                {
                    uni(k, c);
                }
            }
            else
            {
                puts(get(e[k].a) == get(e[k].b) ? "DA" : "NET");
            }
        }
    }
}