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

// Write down the limits of the problem here

struct Card{
    unsigned char rank, suit;
    Card() {}
    Card(const string& s) : rank(s[0]), suit(s[1]) {}
    inline bool operator<(const Card& c){
        return rank < c.rank;
    }
};

const unsigned char flush_order[] = {'A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K'};

const unsigned char rank_order[] = {'A', 'K', 'Q', 'J', 'T', '9', '8', '7', '6', '5', '4', '3', '2'};

int eval(vector<Card> &hand){
    multiset<int> ranks;
    set<int> ranks_s;
    bool same_suit = true;
    bool royal = true;
    bool straight = false;
    int foo = -1;
    for (auto& i : hand){
        if (foo == -1) foo = i.suit;
        else if (foo != i.suit) same_suit = false;
        ranks.insert(i.rank);
        ranks_s.insert(i.rank);
        if ('1' <= i.rank && i.rank <= '9') royal = false;
    }
    if (royal && same_suit) return 10;
    for (int i = 0; i < 9; i++){
        bool ok = true;
        for (int j = 0; j < 5; j++){
            if (!ranks.count(flush_order[i + j])){
                ok = false;
                continue;
            }
        }
        if (ok){
            straight = true;
            break;
        }
    }
    if (same_suit && straight) return 9;
    if (ranks_s.size() == 2 && (ranks.count(*ranks_s.begin()) == 1 || ranks.count(*ranks_s.begin()) == 4)) return 8;
    if (ranks_s.size() == 2) return 7;
    if (ranks_s.size() == 5 && same_suit) return 6;
    if (straight) return 5;
    if (ranks_s.size() == 3 && (ranks.count(*ranks_s.begin()) == 3 ||
                                (ranks.count(*ranks_s.begin()) == 1 && ranks.count(*next(ranks_s.begin())) == 3) ||
                                (ranks.count(*ranks_s.begin()) == 1 && ranks.count(*next(ranks_s.begin())) == 1))) return 4;
    if (ranks_s.size() == 3) return 3;
    if (ranks_s.size() == 4) return 2;

    return 1;
}

int main() {
	// Try to avoid cin, cout :)

	int tc = 1; cin >> tc;
    while(tc--) {
		/// Your solution here
	    string s;
        vector<Card> Alice, Bob, common;
        for (int i = 0; i < 2; i++){
            cin >> s; Alice.push_back(Card(s));
        }
        for (int i =0;i < 2; i++){
            cin >> s;
            Bob.push_back(Card(s));
        }

        for (int i= 0; i < 6; i++){
            cin >> s;
            common.push_back(Card(s));
        }
        int win_a = 0;
        int win_b = 0;
        int draw = 0;
        for (int i = 0; i < 6; i++){
            Alice.push_back(common[i]);
            for (int j= i + 1; j < 6; j++){
                Alice.push_back(common[j]);
                for (int k = j + 1; k < 6; k++){
                    Alice.push_back(common[k]);
                    for (int ii = 0; ii < 6; ii++){
                        if (ii == i || ii == j || ii == k) continue;
                        Bob.push_back(common[ii]);
                    }
                    int scr_a = eval(Alice);
                    int scr_b = eval(Bob);
                    if (scr_a > scr_b) win_a++;
                    else if (scr_b > scr_a) win_b++;
                    else if (scr_a == scr_b){
                        bool ok = false;
                        for (auto ii : rank_order){
                            bool has_a = false, has_b = false;
                            for (auto jj : Alice) if (jj.rank == ii){
                                has_a = true;
                                break;
                            }
                            for (auto jj : Bob) if (jj.rank == ii){
                                has_b = true;
                                break;
                            }
                            if (has_a && has_b) continue;
                            if (has_a){
                                win_a++;
                                ok = true;
                                break;
                            }
                            if (has_b){
                                win_b++;
                                ok = true;
                                break;
                            }
                        }
                        if (!ok) draw++;
                    }
                    Alice.pop_back();
                }
                Alice.pop_back();
            }
            Alice.pop_back();
        }
        if (draw) cout << "Draw\n";
        else if (win_a >= win_b) cout << "Alice\n";
        else cout << "Bob\n";
	}
	return 0;
}

/*
 * Ermm don't underestimate Div2A, pls...
 * 
 * IMPORTANT:: If there isn't a clear-cut approach for your program, DO NOT CODE YET!
 * 
 * Analyze the time complexity and space complexity even if it *seems* efficient
 *
 * Write down some notes for more complicated problems
 * 
 * Also, please, CP isn't supposed to be complicated
 * 
**/