#include <cstring>
#include <cassert>
#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;

        B[0] = 0;
        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;

        for (int i = 0; i <= B[0]; ++i)
            E[i] = B[i];

        //if (B[1] == 0)
        //    ok = false;

        C[1] = E[1] / 2;
        C[N] = E[1] - C[1];
        for (int i = 2; i <= (N + 1) / 2 && ok; ++i)
        {
            if (E[i] < 0)
            {
                int mul = (0 - E[i]) / 10 + ((0 - E[i]) % 10 != 0);
                E[i] += 10 * mul;
                E[i + 1] -= mul;
            }
            if (E[i] >= 10)
            {
                E[i + 1] += E[i] / 10;
                E[i] %= 10;
            }

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

            if (E[i] <= 8 && ((C[i - 1] + C[N - (i - 1) + 1]) + 10 + 1) % 10 == (E[N - (i - 1) + 1] + 10) % 10)
            {
                C[i] = (E[i] + 10) / 2;
                C[N - i + 1] = (E[i] + 10) - C[i];
                --E[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

        /*for (int i = 0; i <= B[0]; ++i)
            E[i] = B[i];

        ok = true;

        if (E[N] != 1 || E[1] == 9)
        {
            ok = false;
            fout << "NU\n";
            continue;
        }
        E[N - 1] += 10;
        --N;

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

        if (N != 1)
        {
            C[1] = (E[1] + 10) / 2;
            C[N] = (E[1] + 10) - C[1];
        }
        else
            C[1] = E[1] / 2;

        --E[2];
        for (int i = 2; i <= (N + 1) / 2 && ok; ++i)
        {
            if (E[i] < 0)
            {
                int mul = (0 - E[i]) / 10 + ((0 - E[i]) % 10 != 0);
                E[i] += 10 * mul;
                E[i + 1] -= mul;
            }
            if (E[i] >= 10)
            {
                E[i + 1] += E[i] / 10;
                E[i] %= 10;
            }

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

            if (E[i] <= 8 && ((C[i - 1] + C[N - (i - 1) + 1]) + 10 + 1) % 10 == (E[N - (i - 1) + 1] + 10) % 10)
            {
                C[i] = (E[i] + 10) / 2;
                C[N - i + 1] = (E[i] + 10) - C[i];
                --E[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;
            }
        }

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

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

        fout << "NU\n";
    }

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