#include <bits/stdc++.h>
using namespace std;

struct node
{
    int same;
    int num;
    bool operator<(node const &o) const
    {
        if (same == o.same)
            return num < o.num;
        else
            return same < o.same;
    }
};

int num[2][20] = {0};
int col[2][5] = {0};
int handClass[2] = {0};
priority_queue<node> pairQueue[2];
priority_queue<node> testPairQueue[2];

void init()
{
    for (int i = 0; i < 20; i++)
    {
        num[0][i] = 0;
        num[1][i] = 0;
    }
    for (int i = 0; i < 5; i++)
    {
        col[0][i] = 0;
        col[1][i] = 0;
    }
    handClass[0] = 1;
    handClass[1] = 1;
    for (int i = 0; i < 2; i++)
    {
        while (pairQueue[i].size())
            pairQueue[i].pop();
        while (testPairQueue[i].size())
            testPairQueue[i].pop();
    }
}

void add_col(char c, int p)
{
    switch (c)
    {
    case 'S':
        col[p][0]++;
        break;
    case 'H':
        col[p][1]++;
        break;
    case 'C':
        col[p][2]++;
        break;
    case 'D':
        col[p][3]++;
        break;
    }
}

void add_num(char c, int p)
{
    switch (c)
    {
    case 'T':
        num[p][10]++;
        break;
    case 'J':
        num[p][11]++;
        break;
    case 'Q':
        num[p][12]++;
        break;
    case 'K':
        num[p][13]++;
        break;
    case 'A':
        num[p][1]++;
        num[p][14]++;
        break;
    default:
        num[p][c - '0']++;
        break;
    }
}

int check_king(int p)
{
    int flag = 1;
    for (int i = 10; i < 15; i++)
    {
        if (num[p][i] == 0)
        // if (num[i] == 0)
        {
            flag = 0;
            break;
        }
    }
    return flag;
}

int common_compare()
{
    for (int i = 14; i > 0; i--)
    {
        if (num[0][i] == num[1][i])
        {
            continue;
        }
        if (num[0][i] > num[1][i])
        {
            // 从大向小比较，先大的说明大牌多，获胜
            return 0;
        }
        else
        {
            return 1;
        }
    }
    return 2;
}

int special_compare()
{
    int minA = -1;
    int minB = -1;
    for (int i = 1; i < 15; i++)
    {
        if (num[0][i] == num[0][i + 1] && num[0][i] != 0)
        {
            minA = i;
            break;
        }
    }
    for (int i = 1; i < 15; i++)
    {
        if (num[1][i] == num[1][i + 1] && num[1][i] != 0)
        {
            minB = i;
            break;
        }
    }
    if (minA == minB)
    {
        return 2;
    }
    else if (minA > minB)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

int compare(int c)
{
    //  c 表示牌型，不同的判断不一样。
    // 返回 2 表示平局，返回 0 或者 1 表示对应的人获胜
    int ans = -1;
    switch (c)
    {
    case 9:; // 同花顺，顺序比较即可，但是因为有 A 所以要特判
    case 5:  // 顺子，顺序比较即可，但是因为有 A 所以要特判
        ans = special_compare();
        break;
    case 10:
        ans = 2; // 皇家同花顺，都是平局
    case 6:;     // 同花，顺序从大向小比较即可
    case 1:      // 啥也不是，顺序从大向小比较即可
        ans = common_compare();
        break;
    case 8: // 四个相同，先看相同的，再看剩下的那一张
        if (pairQueue[0].top().num == pairQueue[1].top().num)
        {
            ans = common_compare();
            // ans = 2;
        }
        else if (pairQueue[0].top().num < pairQueue[1].top().num)
        {
            ans = 1;
        }
        else
        {
            ans = 0;
        }
        break;
    case 7: // 先看三个，再看两个
        if (pairQueue[0].top().num == pairQueue[1].top().num)
        {
            // 三个相等，无法判断，所以要看两个了
            pairQueue[0].pop();
            pairQueue[1].pop();
            if (pairQueue[0].top().num == pairQueue[1].top().num)
            {
                // 一共五张牌，3 和 2 都相等，没必要在看了，直接平局
                ans = 2;
            }
            else if (pairQueue[0].top().num < pairQueue[1].top().num)
            {
                ans = 1;
            }
            else
            {
                ans = 0;
            }

        } // 否则可以判断
        else if (pairQueue[0].top().num < pairQueue[1].top().num)
        {
            ans = 1;
        }
        else
        {
            ans = 0;
        }
        break;
    case 4: // 先看三个，剩下的单张顺序比较
        if (pairQueue[0].top().num == pairQueue[1].top().num)
        {
            ans = common_compare();
        } // 否则可以判断
        else if (pairQueue[0].top().num < pairQueue[1].top().num)
        {
            ans = 1;
        }
        else
        {
            ans = 0;
        }
        break;
    case 3: // 先看大对，再看小对，最后看单张
        if (pairQueue[0].top().num == pairQueue[1].top().num)
        {
            // 大对相等，看小对
            pairQueue[0].pop();
            pairQueue[1].pop();
            if (pairQueue[0].top().num == pairQueue[1].top().num)
            {
                ans = common_compare();
                // ans = 2;
            } // 小对可判断
            else if (pairQueue[0].top().num < pairQueue[1].top().num)
            {
                ans = 1;
            }
            else
            {
                ans = 0;
            }
        } // 否则可以判断
        else if (pairQueue[0].top().num < pairQueue[1].top().num)
        {
            ans = 1;
        }
        else
        {
            ans = 0;
        }
        break;
    case 2: // 先看单对，再看单张顺序
        if (pairQueue[0].top().num == pairQueue[1].top().num)
        {
            ans = common_compare();
        } // 否则可以判断
        else if (pairQueue[0].top().num < pairQueue[1].top().num)
        {
            ans = 1;
        }
        else
        {
            ans = 0;
        }
        break;
    }
    return ans;
}

void check()
{
    string alice = "";
    string bob = "";
    int flag_col[2] = {0};
    int flag_num_con[2] = {0};
    priority_queue<int> flag_num_pair[2];
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            if (col[i][j] == 5) // 说明是同花
            {
                flag_col[i] = 1;
                break;
            }
        }
        int cnt = 0;
        node temp;
        for (int j = 1; j < 14; j++)
        {
            if (num[i][j] == 1 && num[i][j + 1] == 1)
            {
                cnt++;
            }
            else
            {
                cnt = 0;
            }
            if (cnt == 4) // 判断是不是连续五张
            {
                flag_num_con[i] = 1;
            }
            if (num[i][j] >= 2) // 判断是不是对子或者是三张相同
            {
                temp.same = num[i][j];
                temp.num = j;
                if (temp.num == 1)
                    temp.num = 14;
                pairQueue[i].push(temp);
                testPairQueue[i].push(temp);
                flag_num_pair[i].push(num[i][j]);
            }
        }
    }

    // cout << "+++++++  Alice:\n"
    //      << flag_col[0] << " " << flag_num_con[0] << endl;
    // cout << "+++++++  Bob:\n"
    //      << flag_col[1] << " " << flag_num_con[1] << endl;
    // 我们规定牌型按照从小到大，从1到10，每次赋值取 max
    for (int i = 0; i < 2; i++) // 判断两种同花的情况，区别在一个顺，一个不顺
    {
        if (flag_col[i])
        {
            // 是同花
            if (flag_num_con[i])
            {
                // 是顺子，因此满足同花顺，再判断是不是为皇家同花顺
                if (check_king(i))
                {
                    // 是皇家同花顺
                    handClass[i] = max(handClass[i], 10);
                }
                else
                {
                    // 只是普通同花顺
                    handClass[i] = max(handClass[i], 9);
                }
            }
            else
            {
                // 不是顺子，因此满足同花标准
                handClass[i] = max(handClass[i], 6);
            }
        }
        else
        {
            continue;
        }
    }
    for (int i = 0; i < 2; i++) // 判断是不是连续的，即是不是顺子
    {
        if (flag_num_con[i])
        {
            handClass[i] = max(handClass[i], 5);
        }
    }
    for (int i = 0; i < 2; i++) // 判断对子了开始。
    {
        int pairCount = 0; // 这个计数器只记录两张相同
        int flagThree = 0; // 统计三张相同
        int flagFour = 0;  // 统计四张相同
        int now = 0;
        while (flag_num_pair[i].size())
        {
            now = flag_num_pair[i].top();
            flag_num_pair[i].pop();
            switch (now)
            {
            case 2:
                pairCount++;
                break;
            case 3:
                flagThree = 1;
                break;
            case 4:
                flagFour = 1;
                break;
            }
        }
        if (flagFour)
        {
            handClass[i] = max(handClass[i], 8);
            continue;
        }
        else
        {
            if (flagThree)
            {
                // 这里有两种牌型，一种是 3+2 ，一种是单 3
                if (pairCount)
                {
                    // 说明是 3+2
                    handClass[i] = max(handClass[i], 7);
                }
                else
                {
                    // 说明是单 3
                    handClass[i] = max(handClass[i], 4);
                }
            }
            else
            {
                if (pairCount == 2)
                {
                    // 如果有两对
                    handClass[i] = max(handClass[i], 3);
                }
                else if (pairCount == 1)
                {
                    // 如果有一对
                    handClass[i] = max(handClass[i], 2);
                }
                else
                {
                    // 啥也不是，默认为1
                    continue;
                }
            }
        }
    }
    // 所有牌型都确定好了，然后判断牌型是不是相等
    if (handClass[0] == handClass[1])
    {
        // 说明牌型相等，要判断字典序，直接返回下标，如果返回 2 ，则说明平局
        int bigger = compare(handClass[0]);
        switch (bigger)
        {
        case 0:
            cout << "Alice";
            break;
        case 1:
            cout << "Bob";
            break;
        case 2:
            cout << "Draw";
            break;
        }
    }
    else
    {
        // 说明牌型不相等，直接输出较大的获胜
        if (handClass[0] > handClass[1])
        {
            cout << "Alice";
        }
        else
        {
            cout << "Bob";
        }
    }

    // cout << "\n##########\nPair of poker is:\n";
    // for (int i = 0; i < 2; i++)
    // {
    //     if (i)
    //     {
    //         puts("Bob:");
    //     }
    //     else
    //     {
    //         puts("Alice:");
    //     }
    //     while (testPairQueue[i].size())
    //     {
    //         node temp = testPairQueue[i].top();
    //         testPairQueue[i].pop();
    //         cout << temp.same << " " << temp.num << endl;
    //     }
    // }
    // cout << endl
    //      << "Classs : \n"
    //      << "Alice is " << handClass[0] << endl
    //      << "Bob is " << handClass[1] << endl;
}

// void out()
// {
//     cout << "+++++++++++++++\n";
//     for (int i = 0; i < 2; i++)
//     {
//         if (i)
//             cout << "Bob:\n";
//         else
//             cout << "Alice:\n";
//         cout << "color: \n";
//         for (int j = 0; j < 4; j++)
//         {
//             cout << col[i][j] << " ";
//         }
//         cout << "\nnumber:\n";
//         for (int j = 1; j < 15; j++)
//         {
//             cout << num[i][j] << " ";
//         }
//         cout << endl;
//     }
//     cout << "+++++++++++++++\n";
// }

void solve()
{
    string poker;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            cin >> poker;
            add_col(poker[0], i);
            add_num(poker[1], i);
        }
    }
    // out();
    check();
}

int main()
{
    int t;
    int fff = 0;
    cin >> t;
    while (t--)
    {
        if (fff)
            cout << endl;
        fff = 1;
        init();
        solve();
    }
    return 0;
}