// Arup Guha
// 5/10/2023
// Solution to 2022 UCF HS Online Contest Problem: Porcupine Battles
// Note: I am not confident this is correct, but it passes the data.

import java.util.*;

public class porcupine {

	public static int n;
	public static int m;
	public static ArrayList<animal> jean;
	public static ArrayList<animal> pierre;
	public static PriorityQueue<animal> jPQ;
	public static PriorityQueue<animal> pPQ;
	public static int alive;
	
	public static void main(String[] args) {
	
		Scanner stdin = new Scanner(System.in);
		int nC = stdin.nextInt();
		
		// Process cases.
		for (int loop=1; loop<=nC; loop++) {
		
			n = stdin.nextInt();
			m = stdin.nextInt();
			jean = new ArrayList<animal>();
			jPQ = new PriorityQueue<animal>();
			pierre = new ArrayList<animal>();
			pPQ = new PriorityQueue<animal>();

			// Store Jean - I am doing index 0 in the front, hence the reverse.
			for (int i=0; i<n; i++) {
				int att = stdin.nextInt();
				int hea = stdin.nextInt();
				int lev = stdin.nextInt();
				animal tmp = new animal(n-1-i, att, hea, lev);
				jean.add(tmp);
				jPQ.add(tmp);
			}
			Collections.reverse(jean);
			
			// And Pierre.
			for (int i=0; i<m; i++) {
				int att = stdin.nextInt();
				int hea = stdin.nextInt();
				int lev = stdin.nextInt();
				animal tmp = new animal(i, att, hea, lev);
				pierre.add(tmp);	
				pPQ.add(tmp);
			}
			
			// i = index into jean, j = index into pierre.
			int i = 0, j = 0;
			alive = 0;
			
			// Keep going until one team is gone.
			while (i<n && j<m) {
			
				// Assume i and j are at alive porcupines.
				int nKP = (pierre.get(j).h+jean.get(i).a-1-alive)/jean.get(i).a;
				int nKJ = (jean.get(i).h+pierre.get(j).a-1-alive)/pierre.get(j).a;
				
				// Pierre's porcupine dies.
				if (nKP < nKJ) {
					
					// Jean's new health.
					int jeanH =	jean.get(i).h - nKP*pierre.get(j).a;
					
					// Update Jean.
					animal tmp = new animal(jean.get(i).i, jean.get(i).a, jeanH,  jean.get(i).l);
					jean.set(i, tmp);
					jPQ.offer(tmp);
					
					// Kill Pierre's animal. Update level of health necessary to be alive.
					pierre.get(j).alive = false;
					alive += 2*pierre.get(j).l;
				}
				
				
				// Jean's porcupine dies.
				else if (nKJ < nKP) {
				
					// Pierre's new health and update.
					int pierreH = pierre.get(j).h - nKJ*jean.get(i).a;
					animal tmp = new animal(pierre.get(j).i, pierre.get(j).a, pierreH,  pierre.get(j).l);
					pierre.set(j, tmp);
					pPQ.offer(tmp);
					
					// Kill Jean's animal. Update level to be alive.
					jean.get(i).alive = false;
					alive += 2*jean.get(i).l;
				}
				
				// Both die!
				else {
					jean.get(i).alive = false;
					pierre.get(j).alive = false;
					alive += (2*pierre.get(j).l+2*jean.get(i).l);
				}
				
				// Process priority queues.
				update();
				
				// Get to next animals that are alive.
				while (i<n && !jean.get(i).alive) i++;
				while (j<m && !pierre.get(j).alive) j++;
			}
			
			// Output results!
			if (i < n)
				System.out.println("Day #"+loop+": Jean Wins!");
			else if (j < m)
				System.out.println("Day #"+loop+": Pierre Wins!");
			else
				System.out.println("Day #"+loop+": Draw!");
		}
	}
	
	public static void update() {
		
		// Run till no one new dies.
		while (true) {
			
			// Process all of Jean's animals that now die...
			long add = 0;
			while (jPQ.size() > 0 && jPQ.peek().h <= alive) {
				
				// Take from queue, but skip if already dead.
				animal kill = jPQ.poll();
				if (!jean.get(kill.i).alive) continue;
				
				// Update add and kill this animal.
				add += (2*kill.l);
				jean.get(kill.i).alive = false;
			}
			
			// Do same for Pierre.
			while (pPQ.size() > 0 && pPQ.peek().h <= alive) {
				animal kill = pPQ.poll();
				if (!pierre.get(kill.i).alive) continue;
				add += (2*kill.l);
				pierre.get(kill.i).alive = false;
			}
			
			// No one new was killed.
			if (add == 0) break;
			
			// To avoid overflow.
			if (add > 100000) {
				for (int i=0; i<n; i++) jean.get(i).alive = false;
				for (int i=0; i<m; i++) pierre.get(i).alive = false;
				break;
			}
			
			// Kill some more, maybe?
			alive += add;
		}
		
	}
}

class animal implements Comparable<animal> {

	public int i;
	public int a;
	public int h;
	public int l;
	public boolean alive;
	
	public animal(int idx, int att, int hea, int lev) {
		i = idx;
		a = att;
		h = hea;
		l = lev;
		alive = true;
	}
	
	public int compareTo(animal other) {
		return this.h - other.h;
	}
}