package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD int64 = 1000000007
const solveE2 = true

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) NextInt() int {
	sign, val := 1, 0
	c, err := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, err = fs.r.ReadByte()
		if err != nil {
			return 0
		}
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c, err = fs.r.ReadByte()
		if err != nil {
			return sign * val
		}
	}
	fs.r.UnreadByte()
	return sign * val
}

func id(v, mode int) int {
	return (v-1)*2 + mode
}

func main() {
	in := NewFastScanner()
	n := in.NextInt()
	m := in.NextInt()

	sz := 2 * n
	g := make([][]int, sz)

	for i := 0; i < m; i++ {
		x := in.NextInt()
		y := in.NextInt()
		k := in.NextInt()
		vis := make([]int, k)
		for j := 0; j < k; j++ {
			vis[j] = in.NextInt()
		}
		if k == 0 {
			g[id(x, 1)] = append(g[id(x, 1)], id(y, 0))
		} else if k == 1 {
			if vis[0] == x {
				g[id(x, 0)] = append(g[id(x, 0)], id(y, 0))
			}
			if vis[0] == y {
				g[id(x, 1)] = append(g[id(x, 1)], id(y, 1))
			}
		} else if k == 2 {
			if vis[0] == x && vis[1] == y {
				g[id(x, 0)] = append(g[id(x, 0)], id(y, 1))
			}
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	if solveE2 {
		dp := make([]int64, sz)
		for v := 1; v <= n; v++ {
			dp[id(v, 0)] = 1
		}
		fmt.Fprintln(out, 0)
		for step := 1; step <= 2*n-1; step++ {
			ndp := make([]int64, sz)
			for s := 0; s < sz; s++ {
				if dp[s] == 0 {
					continue
				}
				val := dp[s]
				for _, to := range g[s] {
					ndp[to] += val
					if ndp[to] >= MOD {
						ndp[to] -= MOD
					}
				}
			}
			var ans int64
			for v := 1; v <= n; v++ {
				ans += ndp[id(v, 1)]
				if ans >= MOD {
					ans -= MOD
				}
			}
			fmt.Fprintln(out, ans%MOD)
			dp = ndp
		}
		return
	}

	dist := make([]int, sz)
	parent := make([]int, sz)
	for i := 0; i < sz; i++ {
		dist[i] = -1
		parent[i] = -1
	}
	q := make([]int, 0, sz)
	for v := 1; v <= n; v++ {
		s := id(v, 0)
		dist[s] = 0
		q = append(q, s)
	}

	head := 0
	best := -1
	for head < len(q) {
		cur := q[head]
		head++
		if cur%2 == 1 {
			best = cur
			break
		}
		for _, to := range g[cur] {
			if dist[to] == -1 {
				dist[to] = dist[cur] + 1
				parent[to] = cur
				q = append(q, to)
			}
		}
	}

	if best == -1 || dist[best]+1 > 2*n {
		fmt.Fprintln(out, 0)
		return
	}

	states := make([]int, 0)
	for x := best; x != -1; x = parent[x] {
		states = append(states, x)
	}
	for i, j := 0, len(states)-1; i < j; i, j = i+1, j-1 {
		states[i], states[j] = states[j], states[i]
	}

	fmt.Fprintln(out, len(states))
	for i, s := range states {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, s/2+1)
	}
	fmt.Fprintln(out)
}