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.BufferedReader;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.util.*;

public class Main implements Runnable {
    static ContestScanner in;
    static Writer out;
    public static void main(String[] args) {
        new Thread(null, new Main(), "", 16 * 1024 * 1024).start();
    }

    public void run() {
        Main main = new Main();
        try {
            in = new ContestScanner();
            out = new Writer();
            main.solve();
            out.close();
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    void solve() throws IOException {
        int n = in.nextInt();
        int m = in.nextInt();
        SCC scc = new SCC(n);
        for (int i = 0; i < n; i++) {
            int c = in.nextInt();
            for (int j = 0; j < c; j++) {
                int v = in.nextInt() - 1;
                scc.add(i, v);
            }
        }
        node = scc.edge;
        s = in.nextInt() - 1;
        used = new boolean[n];
        reach = new boolean[n][2];
        if(dfs(s, 0)) {
            out.println("Win");
            route.add(s);
            StringBuilder sb = new StringBuilder();
            Collections.reverse(route);
            for(int v: route) {
                sb.append(v + 1).append(" ");
            }
            out.println(sb.toString().trim());
            return;
        }
        if(scc.haveLoop(s)) System.out.println("Draw");
        else System.out.println("Lose");
    }

    int s;
    boolean[] used;
    List<Integer>[] node;

    List<Integer> route = new ArrayList<>();
    boolean[][] reach;
    boolean dfs(int v, int c) {
        if(reach[v][c]) return false;
        reach[v][c] = true;
        if(node[v].isEmpty() && c == 1) return true;
        for(int nv: node[v]) {
            if(dfs(nv, c ^ 1)) {
                route.add(nv);
                return true;
            }
        }
        return false;
    }
}

class SCC{
    int n;
    List<Integer>[] edge;
    List<Integer>[] rev;
    int[] retOrder;
    int[] group;
    int[] groupSize;
    int order, k;
    SCC(int n){
        this.n = n;
        edge = new List[n];
        rev = new List[n];
        used = new BitSet(n);
        for(int i=0; i<n; i++){
            edge[i] = new ArrayList<>();
            rev[i] = new ArrayList<>();
        }
        retOrder = new int[n];
        group = new int[n];
    }
    void add(int from, int to){
        edge[from].add(to);
        rev[to].add(from);
    }

    boolean[] usedLoop;
    boolean haveLoop(int s) {
        scc();
        List<Integer>[] node = makeSCCGraph();
        usedLoop = new boolean[k];
        return haveLoopRec(group[s], node);
    }

    boolean haveLoopRec(int v, List<Integer>[] node) {
        if(usedLoop[v]) return false;
        usedLoop[v] = true;
        if(groupSize[v] > 1) return true;
        for(int nv: node[v]) {
            if(haveLoopRec(nv, node)) return true;
        }
        return false;
    }

    List<Integer>[] makeSCCGraph(){
        int size = scc();
        List<Integer>[] node = new List[size];
        groupSize = new int[k];
        for(int i=0; i<size; i++) node[i] = new ArrayList<>();
        for(int i=0; i<n; i++){
            for(int v: edge[i]){
                groupSize[group[i]]++;
                if(group[i]==group[v]) continue;
                node[group[i]].add(group[v]);
            }
        }
        return node;
    }

    BitSet used;
    int scc(){
        used.clear();
        order = 0;
        for(int i=0; i<n; i++){
            if(!used.get(i)) dfs(i);
        }
        used.clear();
        k = 0;
        for(int i=n-1; i>=0; i--){
            if(!used.get(retOrder[i])) rdfs(retOrder[i], k++);
        }
        return k;
    }

    void dfs(int node){
        used.set(node);
        for(int i: edge[node]){
            if(!used.get(i)) dfs(i);
        }
        retOrder[order++] = node;
    }

    void rdfs(int node, int k){
        used.set(node);
        group[node] = k;
        for(int i: rev[node]){
            if(!used.get(i)) rdfs(i, k);
        }
    }
}

@SuppressWarnings("serial")
class MultiSet<T> extends HashMap<T, Integer>{
    @Override public Integer get(Object key){return containsKey(key)?super.get(key):0;}
    public void add(T key,int v){put(key,get(key)+v);}
    public void add(T key){put(key,get(key)+1);}
    public void sub(T key){final int v=get(key);if(v==1)remove(key);else put(key,v-1);}
    public MultiSet<T> merge(MultiSet<T> set)
    {MultiSet<T>s,l;if(this.size()<set.size()){s=this;l=set;}else{s=set;l=this;}
        for(Entry<T,Integer>e:s.entrySet())l.add(e.getKey(),e.getValue());return l;}
}

class Writer extends PrintWriter{
    public Writer(String filename)throws IOException
    {super(new BufferedWriter(new FileWriter(filename)));}
    public Writer()throws IOException{super(System.out);}
}
class ContestScanner implements Closeable{
    private BufferedReader in;private int c=-2;
    public ContestScanner()throws IOException
    {in=new BufferedReader(new InputStreamReader(System.in));}
    public ContestScanner(String filename)throws IOException
    {in=new BufferedReader(new InputStreamReader(new FileInputStream(filename)));}
    public String nextToken()throws IOException {
        StringBuilder sb=new StringBuilder();
        while((c=in.read())!=-1&&Character.isWhitespace(c));
        while(c!=-1&&!Character.isWhitespace(c)){sb.append((char)c);c=in.read();}
        return sb.toString();
    }
    public String readLine()throws IOException{
        StringBuilder sb=new StringBuilder();if(c==-2)c=in.read();
        while(c!=-1&&c!='\n'&&c!='\r'){sb.append((char)c);c=in.read();}
        return sb.toString();
    }
    public long nextLong()throws IOException,NumberFormatException
    {return Long.parseLong(nextToken());}
    public int nextInt()throws NumberFormatException,IOException
    {return(int)nextLong();}
    public double nextDouble()throws NumberFormatException,IOException
    {return Double.parseDouble(nextToken());}
    public void close() throws IOException {in.close();}
}