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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Jenish
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        ScanReader in = new ScanReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ProblemDSleepyGame solver = new ProblemDSleepyGame();
        solver.solve(1, in, out);
        out.close();
    }

    static class ProblemDSleepyGame {
        LinkedList<Integer>[] arrayList;
        boolean[] visited;
        boolean[][] visited1;
        boolean won;
        boolean cc;
        ArrayList<Integer> ans;
        int size = 0;

        public void solve(int testNumber, ScanReader in, PrintWriter out) {

            int n = in.scanInt();
            int m = in.scanInt();

            arrayList = new LinkedList[n + 1];
            visited = new boolean[n + 1];
            won = false;
            cc = false;

            for (int i = 0; i <= n; i++) arrayList[i] = new LinkedList<>();
            for (int i = 1; i <= n; i++) {
                int temp = in.scanInt();
                for (int j = 0; j < temp; j++) arrayList[i].add(in.scanInt());
            }


            int s = in.scanInt();
            checkCYCCLE(s);


            visited1 = new boolean[n + 1][2];
            ans = new ArrayList<>();
            for (int i = 0; i <= 2 * n; i++) {
                ans.add(0);
            }


            dfs(s, 0, 0);


            if (won) {
                out.println("Win");
                for (int i = 0; i < size; i++) {
                    out.print(ans.get(i) + " ");
                }
            } else {
                if (cc) out.println("Draw");
                else out.println("Lose");
            }
        }

        void dfs(int node, int index, int turn) {
            if (won) return;
            if (visited1[node][turn]) return;
            visited1[node][turn] = true;
            ans.set(index, node);
            size++;
            if (turn == 1 && arrayList[node].getSize() == 0) {
                won = true;
                return;
            }
            for (int i = 0; i < arrayList[node].getSize(); i++) {
                int temp = arrayList[node].get(i);
                if (!visited1[temp][turn ^ 1]) {
                    dfs(temp, index + 1, turn ^ 1);
                }
            }
            if (won) return;

            if (!won) {
                size--;
            }
        }

        void checkCYCCLE(int node) {
            visited[node] = true;
            for (int i = 0; i < arrayList[node].getSize(); i++) {
                int temp = arrayList[node].get(i);
                if (visited[temp]) cc = true;
                else checkCYCCLE(temp);
            }
        }

    }

    static class LinkedList<T> {
        private Node<T> rootNode;
        private Node<T> lastNode;
        private Node<T> midNode;
        private int size;

        public LinkedList() {
            rootNode = null;
            lastNode = null;
            midNode = null;
            this.size = 0;
        }

        public void add(T data) {

            if (rootNode == null) {
                rootNode = new Node<>(data);
                lastNode = rootNode;
                midNode = rootNode;

            } else {
                Node<T> NewNode = new Node<>(data);
                NewNode.previous = lastNode;
                lastNode.next = NewNode;
                lastNode = NewNode;
                if (size % 2 == 0) midNode = midNode.next;
            }
            this.size++;
        }

        public T get(int index) {
            if (index < 0 && index >= size)
                throw new ArrayIndexOutOfBoundsException("LinkedList ERROR :: LinkedListOutofBound at index " + index + ".");
            return traverse(index).data;
        }

        public int getSize() {
            return this.size;
        }

        public Node<T> traverse(int index) {
            if (index >= this.size || index < 0)
                throw new ArrayIndexOutOfBoundsException("LinkedList ERROR ::Traversing Error at index " + index + ".");
            Node<T> tempNode;
            int mid = (size - 1) / 2;
            int disFromMid = Math.abs(mid - index);
            int disFromFrist = index;
            int difFromLast = ((size - 1) - index);


            if (disFromFrist <= disFromMid && disFromFrist <= difFromLast) {
                tempNode = rootNode;
                int t = 0;
                while (t < index) {
                    tempNode = tempNode.next;
                    t++;
                }
                return tempNode;
            } else if (disFromMid <= disFromFrist && disFromMid <= difFromLast) {
                tempNode = midNode;
                if (index < (mid)) {
                    int t = index;
                    while (t < mid) {
                        tempNode = tempNode.previous;
                        t++;
                    }
                    return tempNode;
                } else if (index == mid / 2) {
                    return midNode;
                } else {
                    int t = mid;
                    while (t < index) {
                        tempNode = tempNode.next;
                        t++;
                    }
                    return tempNode;

                }

            } else {
                tempNode = lastNode;
                int t = size - 1;
                while (t > index) {
                    tempNode = tempNode.previous;
                    t--;
                }
                return tempNode;

            }

        }

        private class Node<T> {
            Node<T> previous;
            Node<T> next;
            T data;

            public Node(T data) {
                this.data = data;
                this.next = null;
                this.previous = null;
            }

        }

    }

    static class ScanReader {
        private byte[] buf = new byte[4 * 1024];
        private int index;
        private BufferedInputStream in;
        private int Total_Char;

        public ScanReader(InputStream inputStream) {
            in = new BufferedInputStream(inputStream);
        }

        private int scan() {
            if (index >= Total_Char) {
                index = 0;
                try {
                    Total_Char = in.read(buf);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (Total_Char <= 0) return -1;
            }
            return buf[index++];
        }

        public int scanInt() {
            int integer = 0;
            int n = scan();
            while (isWhiteSpace(n)) n = scan();
            int neg = 1;
            if (n == '-') {
                neg = -1;
                n = scan();
            }
            while (!isWhiteSpace(n)) {
                if (n >= '0' && n <= '9') {
                    integer *= 10;
                    integer += n - '0';
                    n = scan();
                }
            }
            return neg * integer;
        }

        private boolean isWhiteSpace(int n) {
            if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
            else return false;
        }

    }
}

