#include <cstring>
#include <fstream>
#include <algorithm>

using namespace std;

int T;
char A[10010];
int B[10010], C[10010], D[10010], E[10010];

int main()
{
    ifstream fin("invers.in");
    ofstream fout("invers.out");

    fin >> T;
    while (T--)
    {
        fin >> (A + 1);

        int sz = 0;
        for (int i = 1; A[i] != 0; ++i, ++sz);

        int N = sz;

        memset(B, 0, sizeof(B));
        for (int i = N; i >= 1; --i)
            B[++B[0]] = A[i] - '0';

        if (N == 1)
        {
            if (B[N] % 2 == 0) fout << "DA\n";
            else               fout << "NU\n";
            continue;
        }

        // B[1] + B[sz] <= 9

        bool ok = true;

        memcpy(E, B, sizeof(E));
        memset(C, 0, sizeof(C));

        C[1] = B[1] / 2;
        C[N] = B[1] - C[1];
        for (int i = 2; i <= (N + 1) / 2 && ok; ++i)
        {
            if (B[i] < 0)
            {
                B[i] += 10;
                B[i + 1] -= 1;
            }
            if (B[i] >= 19)
            {
                ok = false;
                continue;
            }

            C[i] = B[i] / 2;
            C[N - i + 1] = B[i] - C[i];

            if (B[i] <= 9 && ((C[i - 1] + C[N - (i - 1) + 1]) + 10 + 1) % 10 == (B[N - (i - 1) + 1] + 10) % 10)
            {
                C[i] = (B[i] + 10) / 2;
                C[N - i + 1] = (B[i] + 10) - C[i];
                --B[i + 1];
            }
        }

        memset(D, 0, sizeof(D));
        D[0] = N;
        for (int i = 1; i <= N; ++i)
        {
            D[i] += C[i] + C[N - i + 1];
            if (D[i] >= 10 && i != N)
            {
                D[i + 1] += D[i] / 10;
                D[i] %= 10;
            }
        }

        for (int i = 1; i <= N; ++i)
            if (D[i] != E[i])
                ok = false;

        if (ok)
        {
            fout << "DA\n";
            continue;
        }

        // B[1] + B[sz] > 9

        memcpy(B, E, sizeof(B));

        ok = true;

        if (B[N] != 1 || B[1] == 9) ok = false;
        B[N - 1] += 10;
        --N;

        memset(C, 0, sizeof(C));

        C[1] = (B[1] + 10) / 2;
        C[N] = (B[1] + 10) - C[1];

        --B[2];
        for (int i = 2; i <= (N + 1) / 2 && ok; ++i)
        {
            if (B[i] < 0)
            {
                B[i] += 10;
                B[i + 1] -= 1;
            }
            if (B[i] >= 19)
            {
                ok = false;
                continue;
            }

            C[i] = B[i] / 2;
            C[N - i + 1] = B[i] - C[i];

            if (B[i] <= 9 && ((C[i - 1] + C[N - (i - 1) + 1]) + 10 + 1) % 10 == (B[N - (i - 1) + 1] + 10) % 10)
            {
                C[i] = (B[i] + 10) / 2;
                C[N - i + 1] = (B[i] + 10) - C[i];
                --B[i + 1];
            }
        }

        memset(D, 0, sizeof(D));
        D[0] = N;
        for (int i = 1; i <= N; ++i)
        {
            D[i] += C[i] + C[N - i + 1];
            if (D[i] >= 10 && i != N)
            {
                D[i + 1] += D[i] / 10;
                D[i] %= 10;
            }
        }

        E[N] += 10 * E[N + 1];
        for (int i = 1; i <= N; ++i)
            if (D[i] != E[i])
                ok = false;

        if (ok)
        {
            fout << "DA\n";
            continue;
        }

        fout << "NU\n";
    }

    fin.close();
    fout.close();
}