// Arup Guha
// 6/2/2012
// Solution to 2012 World Finals Problem L: Takeover Wars
import java.util.*;

public class l {

	public static void main(String[] args) {

		Scanner stdin = new Scanner(System.in);
		
		// Read in each case.
		int loop = 1;
		while (stdin.hasNext()) {

			int M = stdin.nextInt();
			int N = stdin.nextInt();

			long[] take = new long[M];
			long[] buy = new long[N];

			for (int i=0; i<M; i++)
				take[i] = stdin.nextLong();
			for (int i=0; i<N; i++)
				buy[i] = stdin.nextLong();

			// Setting up greedy.
			Arrays.sort(take);
			Arrays.sort(buy);

			// Reverse both lists.
			for (int i=0; i<M/2; i++) {
				long t = take[i];
				take[i] = take[M-1-i];
				take[M-1-i] = t;
			}

			for (int i=0; i<N/2; i++) {
				long t = buy[i];
				buy[i] = buy[N-1-i];
				buy[N-1-i] = t;
			}

			// We try both strategies.
			boolean method1 = tryMerge(take, buy);
			boolean method2 = tryBuy(take, buy);

			// If either works, here's the answer.
			if (method1 || method2)
				System.out.println("Case "+loop+": Takeover Incorporated");
			else
				System.out.println("Case "+loop+": Buyout Limited");

			loop++;
		}
	}

	// Tries to merge for the first move.
	public static boolean tryMerge(long[] take, long[] buy) {

		LinkedList<Long> t = new LinkedList<Long>();
		for (int i=0; i<take.length; i++)
			t.add(take[i]);

		LinkedList<Long> b = new LinkedList<Long>();
		for (int i=0; i<buy.length; i++)
			b.add(buy[i]);

		// Start with merge.
		long one = t.removeFirst();
		long two = 0;
		if (t.size() > 0)
			two = t.removeFirst();
		t.addFirst(one+two);

		// t already went, so it's b's turn now.
		boolean turn = false;
		while (t.size() > 0 && b.size() > 0) {

			// Execute the greedy strategy.
			if (turn) {

				// Buy
				if (t.peekFirst() > b.peekFirst())
					b.removeFirst();
				
				// Merge
				else {
					one = t.removeFirst();
					two = 0;
					if (t.size() > 0)
						two = t.removeFirst();
					t.addFirst(one+two);
				}
			}
			else {
				
				// Buy
				if (b.peekFirst() > t.peekFirst())
					t.removeFirst();
				
				// Merge
				else {
					one = b.removeFirst();
					two = 0;
					if (b.size() > 0)
						two = b.removeFirst();;
					b.addFirst(one+two);
				}
			}
			turn = !turn;
		}

		// See if Takeover won...
		return t.size() > 0;
	}

	// Try to buy first.
	public static boolean tryBuy(long[] take, long[] buy) {

		LinkedList<Long> t = new LinkedList<Long>();
		for (int i=0; i<take.length; i++)
			t.add(take[i]);

		// Start with buy.
		LinkedList<Long> b = new LinkedList<Long>();
		for (int i=0; i<buy.length; i++)
			b.add(buy[i]);

		// This strategy can't work if this isn't true.
		if (t.peekFirst() > b.peekFirst())
			b.removeFirst();
		else
			return false;

		// t already went, so it's b's turn now.
		boolean turn = false;
		while (t.size() > 0 && b.size() > 0) {

			// Execute the greedy strategy.
			if (turn) {

				// Buy
				if (t.peekFirst() > b.peekFirst())
					b.removeFirst();
				
				// Merge
				else {
					long one = t.removeFirst();
					long two = 0;
					if (t.size() > 0)
						two = t.removeFirst();
					t.addFirst(one+two);
				}
			}
			else {
				
				// Buy
				if (b.peekFirst() > t.peekFirst())
					t.removeFirst();
				
				// Merge
				else {
					long one = b.removeFirst();
					long two = 0;
					if (b.size() > 0)
						two = b.removeFirst();
					b.addFirst(one+two);
				}
			}
			turn = !turn;
		}

		// See if Takeover won...
		return t.size() > 0;
	}
}