11 20
1 2
2 7 6
1 7
4 10 9 3 2
2 9 2
1 3
0
0
3 1 6 7
4 11 7 5 6
2 2 8
4
 5 5
1 2
1 3
2 1 4
1 5
0
1
 5 5
1 2
1 3
2 2 4
1 5
0
1
 4 3
1 2
1 3
1 1
0
1
 6 6
1 2
2 3 6
1 4
0
1 3
1 5
2
 5 5
1 2
2 3 5
1 4
1 2
0
1
 5 5
2 2 3
1 4
1 5
1 3
0
1
 6 6
1 2
2 3 6
1 4
1 5
1 1
0
1
 5 5
1 2
2 4 3
0
1 5
1 2
1
 6 6
2 2 3
1 4
1 4
1 5
1 6
0
1
 5 5
2 2 3
2 4 5
1 5
0
0
1
 5 5
2 2 4
1 3
1 4
1 5
0
1
 57 39
1 57
1 40
1 38
0
0
0
1 20
0
0
1 53
0
0
0
1 36
1 40
1 27
1 11
1 7
1 35
0
1 23
1 44
1 14
1 54
0
1 21
1 28
1 37
1 38
1 26
1 3
0
1 14
0
1 1
1 10
1 52
1 45
0
1 16
0
1 22
1 51
1 48
1 30
1 30
0
1 19
1 33
0
1 45
1 42
1 49
0
1 23
0
1 31
15
 15 20
3 4 9 7
0
1 1
3 5 6 1
1 13
0
4 8 15 4 2
1 7
1 2
0
1 4
0
2 3 11
1 5
2 1 6
4
 5 5
2 2 3
1 4
0
1 5
1 4
2
 6 6
2 2 3
1 4
1 5
0
1 6
1 4
1
 4 4
2 2 4
1 3
1 1
0
3
 2 1
0
1 1
1
 8 8
2 2 5
1 3
1 7
0
1 6
1 8
1 4
1 4
1
 5 5
1 2
1 3
1 4
2 3 5
0
1
 4 4
2 2 3
1 4
1 4
0
1
 5 5
1 2
2 3 4
0
1 5
1 3
1
 6 6
1 2
2 3 4
1 5
1 5
1 6
0
1
 3 2
1 2
1 1
0
3
 5 5
2 2 3
1 5
1 4
1 5
0
1
 92 69
1 76
1 14
1 9
0
1 46
1 80
0
0
1 77
0
1 53
1 81
1 61
1 40
0
1 20
1 71
1 24
1 54
1 82
1 23
0
1 63
1 25
1 38
1 68
0
1 65
0
1 76
1 55
1 87
1 1
1 37
1 68
1 30
1 17
1 19
0
1 16
1 69
0
1 60
1 86
0
1 44
1 32
1 10
1 8
0
0
0
0
0
1 2
1 39
0
1 74
1 5
1 28
1 79
1 32
1 34
0
1 81
1 85
1 6
1 18
0
0
1 58
1 88
1 7
1 78
1 43
1 5
1 61
1 90
1 31
1 75
1 72
1 80
1 13
0
0
1 21
1 70
1 30
0
1 68
1 3
1 62
91
 5 5
2 2 4
1 3
1 1
1 5
0
1
 3 3
1 2
2 1 3
0
1
 6 6
2 2 4
1 3
0
1 5
1 6
1 3
1
 53 38
0
1 35
0
1 32
0
0
1 49
1 25
0
1 19
0
0
1 25
1 48
1 50
1 2
1 4
1 50
1 34
1 4
1 46
0
1 4
1 5
1 43
1 8
1 40
1 47
1 21
1 43
0
1 10
1 27
1 33
1 20
1 26
0
0
0
1 53
0
0
1 45
1 23
1 7
1 52
1 51
0
1 29
1 48
1 36
1 2
1 28
2
 8 8
2 2 3
1 4
1 4
1 5
1 6
0
1 8
1 7
1
 5 5
1 2
1 3
1 4
2 2 5
0
1

Win
4 10 11 8
 Win
1 2 3 1 2 3 4 5
 Draw
 Draw
 Lose
 Win
1 2 3 4 2 5
 Lose
 Win
1 2 3 4 5 1 2 6
 Win
1 2 4 5 2 3
 Lose
 Lose
 Lose
 Draw
 Win
4 5 13 3 1 4 5 13 3 1 9 2
 Draw
 Lose
 Win
3 1 2 3 1 4
 Lose
 Lose
 Draw
 Lose
 Lose
 Lose
 Lose
 Win
1 3 4 5
 Lose
 Win
1 2 3 1 4 5
 Draw
 Lose
 Draw
 Lose
 Win
1 2 3 4 2 3 4 5

import java.io.*;
import java.util.*;

public class Codeforces937D {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		
		//directed adjacency list and edges list
		int[] degree = new int[n];
		int[][] adjacency = new int[n][];
		int[][] edges = new int[m][2];
		int edgecounter = 0;
		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());
			degree[i] = Integer.parseInt(st.nextToken());
			adjacency[i] = new int[degree[i]];
			for (int j = 0; j < degree[i]; j++) {
				adjacency[i][j] = Integer.parseInt(st.nextToken())-1;
				edges[edgecounter][0] = i;
				edges[edgecounter][1] = adjacency[i][j];
				edgecounter++;
			}
		}
		
		st = new StringTokenizer(br.readLine());
		int s = Integer.parseInt(st.nextToken())-1;
		
		//DFS tour from s
		boolean[] explored = new boolean[n];
		int[] parent = new int[n];
		for (int i = 0; i < n; i++) {
			parent[i] = i;
		}
		int[] postvisit = new int[n];
		int[] postcounter = new int[1];
		
		//do the DFS
		search(adjacency, n, s, explored, parent, postvisit, postcounter);
		
		int[] randomchild = new int[n];
		for (int i = 0; i < n; i++) {
			randomchild[i] = -1;
		}
		for (int i = 0; i < n; i++) {
			randomchild[parent[i]] = i;
		}
		
		//topological order of found things
		int[] toposorted = new int[postcounter[0]];
		for (int i = 0; i < postcounter[0]; i++) {
			toposorted[i] = postvisit[postcounter[0]-1-i];
		}
		
		//DFS from all end vertices
		int[][] reverseAdjacency = toadjacency(edges, n);
		boolean[] reverse = new boolean[n];
		for (int i = 0; i < n; i++) {
			if (degree[i] == 0) {
				search2(reverseAdjacency, n, i, reverse);
			}
		}
		
		//reverse topological order
		int[] order = new int[n];
		for (int i = 0; i < postcounter[0]; i++) {
			order[toposorted[i]] = i+1;
		}
		
		//distance via DFS
		int[] distance = new int[n];
		for (int i = 1; i < postcounter[0]; i++) {
			distance[toposorted[i]] = distance[parent[toposorted[i]]]+1;
		}
		
		//check if you can reach any dead ends.  if not, then instant draw
		//also check if DFS itself gives a win
		boolean deadend = false;
		int win = -1;
		for (int i = 0; i < n; i++) {
			if ((degree[i] == 0) && explored[i]) {
				deadend = true;
				if (distance[i]%2 == 1) {
					win = i;
				}
			}
		}
		
		if (deadend) {
			if (win >= 0) {
				pw.println("Win");
				int[] winarray = new int[distance[win]+1];
				winarray[distance[win]] = win;
				for (int i = distance[win]-1; i >= 0; i--) {
					winarray[i] = parent[winarray[i+1]];
				}
				for (int i = 0; i <= distance[win]; i++) {
					pw.print(winarray[i]+1 + " ");
				}
			}
			else {
				boolean drawpossible = false;
				boolean winpossible = false;
				for (int i = 0; (i < m) && !(winpossible); i++) {
					if (order[edges[i][0]] > order[edges[i][1]]) {
						//reached cycle
						drawpossible = true;
						if ((distance[edges[i][0]]%2 == distance[edges[i][1]]%2) && (reverse[edges[i][1]])) {
							winpossible = true;
							pw.println("Win");
							int[] firstarray = new int[distance[edges[i][0]]+1];
							firstarray[distance[edges[i][0]]] = edges[i][0];
							for (int j = distance[edges[i][0]]-1; j >= 0; j--) {
								firstarray[j] = parent[firstarray[j+1]];
							}
							for (int j = 0; j <= distance[edges[i][0]]; j++) {
								pw.print(firstarray[j]+1 + " ");
							}
							int current = edges[i][1];
							pw.print(current+1 + " ");
							while (randomchild[current] >= 0) {
								current = randomchild[current];
								pw.print(current+1 + " ");
							}
						}
					}
					else if (parent[edges[i][1]] != parent[edges[i][0]]) {
						if ((distance[edges[i][0]]%2 == distance[edges[i][1]]%2) && (reverse[edges[i][1]])) {
							winpossible = true;
							pw.println("Win");
							int[] firstarray = new int[distance[edges[i][0]]+1];
							firstarray[distance[edges[i][0]]] = edges[i][0];
							for (int j = distance[edges[i][0]]-1; j >= 0; j--) {
								firstarray[j] = parent[firstarray[j+1]];
							}
							for (int j = 0; j <= distance[edges[i][0]]; j++) {
								pw.print(firstarray[j]+1 + " ");
							}
							int current = edges[i][1];
							pw.print(current+1 + " ");
							while (randomchild[current] >= 0) {
								current = randomchild[current];
								pw.print(current+1 + " ");
							}
						}
					}
				}
				
				if (!(winpossible)) {
					if (drawpossible)
						pw.println("Draw");
					else
						pw.println("Lose");
				}
			}
		}
		
		else {
			pw.println("Draw");
		}
		
		pw.close();
	}
	
	//converts list of edges to adjacency list
		public static int[][] toadjacency(int[][] list, int v) {
			int[] counter = new int[v];
			int n = list.length;
			for (int i = 0; i < n; i++) {
				counter[list[i][1]]++;
			}
			int[][] adjacency = new int[v][];
			for (int i = 0; i < v; i++) {
				adjacency[i] = new int[counter[i]];
			}
			int[] counter2 = new int[v];
			for (int i = 0; i < n; i++) {
				adjacency[list[i][1]][counter2[list[i][1]]] = list[i][0];
				counter2[list[i][1]]++;
			}
			
			return adjacency;
		}
	
	public static void search(int[][] adjacency, int n, int v, boolean[] explored, int[] parent, int[] postvisit, int[] postcounter) {
		explored[v] = true;
		int k = adjacency[v].length;
		for (int i = 0; i < k; i++) {
			int w = adjacency[v][i];
			if (!(explored[w])) {
				parent[w] = v;
				search(adjacency, n, w, explored, parent, postvisit, postcounter);
			}
		}
		postvisit[postcounter[0]] = v;
		postcounter[0]++;
	}
	public static void search2(int[][] adjacency, int n, int v, boolean[] explored) {
		explored[v] = true;
		int k = adjacency[v].length;
		for (int i = 0; i < k; i++) {
			int w = adjacency[v][i];
			if (!(explored[w])) {
				search2(adjacency, n, w, explored);
			}
		}
	}
}
