import java.util.*;

// Solution to "Poker"
// Sat Oct 17 19:52:51 CDT 2015
// Author: Greg Hamerly (hamerly@cs.baylor.edu)

public class poker_hamerly {
    public static class Card implements Comparable<Card> {
        public Card(String card) {
            rank = ranks.get(card.substring(0, card.length() - 1));
            suit = card.charAt(card.length() - 1);
        }
        public int rank;
        public char suit;
        public int compareTo(Card other) { return rank - other.rank; }
    }

    static Map<String, Integer> ranks = new HashMap<String, Integer>();
    static {
        for (int r = 2; r <= 9; ++r) ranks.put("" + r, r);
        ranks.put("T", 10);
        ranks.put("J", 11);
        ranks.put("Q", 12);
        ranks.put("K", 13);
        ranks.put("A", 14);
    }

    public static boolean isFlush(Vector<Card> hand) {
        char s = hand.elementAt(0).suit;
        for (Card c : hand)
            if (s != c.suit)
                return false;
        return true;
    }

    public static boolean isStraight(Vector<Card> hand) {
        int r = hand.elementAt(0).rank - 1;
        for (Card c : hand) {
            if (r + 1 != c.rank)
                return false;
            r = c.rank;
        }
        return true;
    }

    // encode N integers as MAX - (14^(N-1) * ranks[0] + 14^(N-2) * ranks[1] + ... + 14 * ranks[N-2] + ranks[0)
    // where MAX = 14^N + 14^(N-1) + ... + 14^2 + 14
    public static int encode(int ... ranks) {
        int e = 0, max = 0;
        for (int r : ranks) {
            e = e * 14 + r;
            max = 14 * (max + 1);
        }
        return max - e;
    }

    // give a numeric score to this hand; lower scores are higher-value hands
    public static int score(Vector<Card> hand) {
        assert(hand.size() == 5);

        Collections.sort(hand);

        int a = hand.elementAt(0).rank;
        int b = hand.elementAt(1).rank;
        int c = hand.elementAt(2).rank;
        int d = hand.elementAt(3).rank;
        int e = hand.elementAt(4).rank;

        boolean flush = isFlush(hand);
        boolean straight = isStraight(hand);

        // minrank represents the minimum rank of hands of this type
        int minrank = 0;

        // numEncodings[i] represents the number of ways there are to encode i cards
        int numEncodings[] = new int[6];
        for (int i = 1; i < numEncodings.length; ++i)
            numEncodings[i] = 14 * (numEncodings[i-1] + 1);

        // ROYAL FLUSH or STRAIGHT FLUSH: encode(highest card)
        if (flush && straight) return minrank + encode(e);
        minrank += numEncodings[1];

        // FOUR OF A KIND: encode(shared rank of the four)
        if (b == e || a == d) return minrank + encode(d);
        minrank += numEncodings[1];

        // FULL HOUSE: encode(shared rank of the three)
        if ((a == b && c == e) || (a == c && d == e)) return minrank + encode(c);
        minrank += numEncodings[1];

        // FLUSH: encode(all cards)
        if (flush) return minrank + encode(e, d, c, b, a);
        minrank += numEncodings[5];

        // STRAIGHT: encode(high card)
        if (straight) return minrank + encode(e);
        minrank += numEncodings[1];

        // THREE OF A KIND: encode(shared rank of the three)
        if (a == c || b == d || c == e) return minrank + encode(c);
        minrank += numEncodings[1];

        // TWO PAIR: encode(higher pair rank, lower pair rank, kicker rank)
        if ((d == e || c == d) && (b == c || a == b)) {
            int kicker = (a != b) ? a : ((b != c) ? c : e);
            return minrank + encode(d, b, kicker);
        }
        minrank += numEncodings[3];

        // ONE PAIR: encode(pair rank, high kicker, mid kicker, low kicker)
        if (d == e || c == d || b == c || a == b) {
            int kicker1 = c, kicker2 = b, kicker3 = a;
            int pair = d;
            if (c == d || b == c || a == b)
                kicker1 = e;
            if (b == c || a == b) {
                kicker2 = d;
                pair = b;
            }
            if (a == b)
                kicker3 = c;
            return minrank + encode(pair, kicker1, kicker2, kicker3);
        }
        minrank += numEncodings[4];

        // NO SPECIALS: encode(all cards)
        return minrank + encode(e, d, c, b, a);
    }

    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);

        int w = Integer.parseInt(input.nextLine());
        for (int i = 0; i < w; ++i) {
            String a[] = input.nextLine().split(" ");
            String b[] = input.nextLine().split(" ");
            Vector<Card> handA = new Vector<Card>();
            Vector<Card> handB = new Vector<Card>();
            for (String c : a) handA.addElement(new Card(c));
            for (String c : b) handB.addElement(new Card(c));

            int scoreA = score(handA);
            int scoreB = score(handB);

            if (scoreA != scoreB) {
                String winningHand[] = (scoreA < scoreB) ? a : b;
                boolean first = true;
                for (String c : winningHand) {
                    if (!first)
                        System.out.print(" ");
                    System.out.print(c);
                    first = false;
                }
                System.out.println();
            } else {
                System.out.println("Tie");
            }
        }
    }
}