Problem: Everybody knows that we have been living in the Matrix for a long time. And in the new seventh Matrix the world is ruled by beavers.

So let's take beaver Neo. Neo has so-called "deja vu" outbursts when he gets visions of events in some places he's been at or is going to be at. Let's examine the phenomenon in more detail.

We can say that Neo's city is represented by a directed graph, consisting of n shops and m streets that connect the shops. No two streets connect the same pair of shops (besides, there can't be one street from A to B and one street from B to A). No street connects a shop with itself. As Neo passes some streets, he gets visions. No matter how many times he passes street k, every time he will get the same visions in the same order. A vision is a sequence of shops.

We know that Neo is going to get really shocked if he passes the way from some shop a to some shop b, possible coinciding with a, such that the list of visited shops in the real life and in the visions coincide.

Suggest beaver Neo such path of non-zero length. Or maybe you can even count the number of such paths modulo 1000000007 (109 + 7)?..

Input

The first line contains integers n and m — the number of shops and the number of streets, correspondingly, 1 ≤ n ≤ 50, <image>. Next m lines contain the descriptions of the streets in the following format: xi yi ki v1 v2 ... vk, where xi and yi (1 ≤ xi, yi ≤ n, xi ≠ yi) are indices of shops connected by a street, ki (0 ≤ ki ≤ n) is the number of visions on the way from xi to yi; v1, v2, ..., vk (1 ≤ vi ≤ n) describe the visions: the numbers of the shops Neo saw. Note that the order of the visions matters.

It is guaranteed that the total number of visions on all streets doesn't exceed 105.

  * to get 50 points, you need to find any (not necessarily simple) path of length at most 2·n, that meets the attributes described above (subproblem E1); 
  * to get 50 more points, you need to count for each length from 1 to 2·n the number of paths that have the attribute described above (subproblem E2). 

Output

Subproblem E1. In the first line print an integer k (1 ≤ k ≤ 2·n) — the numbers of shops on Neo's path. In the next line print k integers — the number of shops in the order Neo passes them. If the graph doesn't have such paths or the length of the shortest path includes more than 2·n shops, print on a single line 0.

Subproblem E2. Print 2·n lines. The i-th line must contain a single integer — the number of required paths of length i modulo 1000000007 (109 + 7).

Examples

Input

6 6
1 2 2 1 2
2 3 1 3
3 4 2 4 5
4 5 0
5 3 1 3
6 1 1 6


Output

4
6 1 2 3


Input

6 6
1 2 2 1 2
2 3 1 3
3 4 2 4 5
4 5 0
5 3 1 3
6 1 1 6


Output

1
2
1
1
2
1
1
2
1
1
2
1

Note

The input in both samples are the same. The first sample contains the answer to the first subproblem, the second sample contains the answer to the second subproblem.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100 + 10;
const int Mod = (int)1e9 + 7;
int n, m;
int g[MAX][MAX], can[MAX][MAX];
vector<int> p[MAX][MAX];
int get(vector<int> &before, int kind, int could, int have) {
  int j;
  int now = 0, cc = have;
  for (; now < (int)before.size(); now++) {
    if (now + 1 == (int)before.size()) break;
    int a = before[now];
    int b = before[now + 1];
    if (g[a][b] != kind || (!could && can[a][b])) return 0;
    vector<int> &nL = p[a][b];
    for ((j) = (0); (j) != ((int)nL.size()); ++(j)) {
      if (cc < (int)before.size()) {
        if (nL[j] == before[cc])
          cc++;
        else
          return 0;
      } else {
        while (j < (int)nL.size()) {
          before.push_back(nL[j++]);
          if ((int)before.size() > 2 * n + 1) return 0;
        }
        cc = before.size();
        break;
      }
    }
  }
  return cc == (int)before.size();
}
int isCan(int a, int b) {
  int i;
  vector<int> &L = p[a][b];
  int len = L.size();
  for ((i) = (0); (i) <= (len - 2); ++(i))
    if (L[i] == a && L[i + 1] == b) return 1;
  return 0;
}
int f_Before[MAX][MAX][MAX], f_After[MAX][MAX][MAX], tmp[MAX][MAX][MAX];
int Before[MAX][MAX], After[MAX][MAX];
int ans[MAX];
void work(int u, int kind, int f[MAX][MAX][MAX]) {
  int v;
  for ((v) = (1); (v) <= (n); ++(v))
    if (g[u][v] == kind && !can[v][u]) {
      vector<int> after;
      after.push_back(u);
      after.push_back(v);
      if (!get(after, kind, kind != 2, 1)) continue;
      int Len = after.size();
      f[u][after[Len - 1]][Len - 1]++;
    }
}
void add(int &a, int b) {
  a += b;
  if (a >= Mod) a -= Mod;
}
void work2(int a, int b) {
  int i, j;
  vector<int> &L = p[a][b];
  int len = L.size();
  for ((i) = (0); (i) <= (len - 2); ++(i))
    if (L[i] == a && L[i + 1] == b) {
      vector<int> before, after;
      for (j = i; j >= 0; --j) before.push_back(L[j]);
      for (j = i + 1; j < len; ++j) after.push_back(L[j]);
      if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
        reverse(before.begin(), before.end());
        int A = before[0];
        int B = after[after.size() - 1];
        int Len = before.size() + after.size() - 1;
        int k, l, o;
        for ((l) = (1); (l) <= (n); ++(l))
          for ((o) = (0); (o) <= (2 * n); ++(o))
            if (tmp[A][l][o])
              for ((k) = (1); (k) <= (n); ++(k))
                if (g[k][l] == 1 && p[k][l].size() == 0 && Len + 1 + o <= 2 * n)
                  add(f_After[k][B][Len + 1 + o], tmp[A][l][o]);
      } else
        return;
    }
  return;
}
int tot = 0, First;
void Dp1(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
  int i, j, k, l, o;
  memset(tmp, 0, sizeof tmp);
  for ((i) = (1); (i) <= (n); ++(i)) tmp[i][i][0] = 1;
  int up = 2 * n;
  for ((l) = (1); (l) <= (up); ++(l))
    for ((i) = (1); (i) <= (n); ++(i))
      for ((j) = (1); (j) <= (n); ++(j))
        for ((o) = (0); (o) <= (l); ++(o))
          if (f[i][j][o])
            for ((k) = (1); (k) <= (n); ++(k))
              if (tmp[j][k][l - o])
                add(tmp[i][k][l],
                    (long long)f[i][j][o] * tmp[j][k][l - o] % Mod);
  for ((i) = (1); (i) <= (n); ++(i))
    for ((j) = (1); (j) <= (n); ++(j))
      for ((l) = (0); (l) <= (2 * n); ++(l)) add(after[i][l], tmp[i][j][l]);
}
void Dp2(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
  int i, j, k, l;
  for ((i) = (1); (i) <= (n); ++(i)) after[i][0] = 1;
  int up = 2 * n;
  for ((l) = (1); (l) <= (up); ++(l))
    for ((i) = (1); (i) <= (n); ++(i))
      for ((j) = (1); (j) <= (n); ++(j))
        for ((k) = (0); (k) != (l); ++(k))
          add(After[i][l], (long long)f[i][j][l - k] * After[j][k] % Mod);
}
void check(int a, int b) {
  int i, j;
  vector<int> &L = p[a][b];
  int len = L.size();
  for ((i) = (0); (i) <= (len - 2); ++(i))
    if (L[i] == a && L[i + 1] == b) {
      vector<int> before, after;
      for (j = i; j >= 0; --j) before.push_back(L[j]);
      for (j = i + 1; j < len; ++j) after.push_back(L[j]);
      if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
        reverse(before.begin(), before.end());
        int A = before[0];
        int B = after[after.size() - 1];
        int Len = before.size() + after.size() - 1;
        int l1, l2;
        for ((l1) = (0); (l1) <= (2 * n); ++(l1))
          for ((l2) = (0); (l2) <= (2 * n); ++(l2))
            if (l1 + l2 + Len <= 2 * n)
              add(ans[l1 + l2 + Len],
                  (long long)Before[A][l1] * After[B][l2] % Mod);
      } else
        return;
    }
  return;
}
int main() {
  int i, j;
  scanf("%d%d", &n, &m);
  for ((i) = (1); (i) <= (m); ++(i)) {
    int a, b;
    scanf("%d%d", &a, &b);
    if (!First) First = a;
    g[a][b] = 1;
    g[b][a] = 2;
    int k, first;
    scanf("%d", &k);
    while (k--) {
      scanf("%d", &first);
      p[a][b].push_back(first);
    }
    p[b][a] = p[a][b];
    reverse(p[b][a].begin(), p[b][a].end());
  }
  for ((i) = (1); (i) <= (n); ++(i))
    for ((j) = (1); (j) <= (n); ++(j))
      if (g[i][j] == 1 && isCan(i, j)) can[j][i] = can[i][j] = 1;
  for ((i) = (1); (i) <= (n); ++(i)) work(i, 1, f_After);
  for ((i) = (1); (i) <= (n); ++(i)) work(i, 2, f_Before);
  Dp1(f_Before, Before);
  for ((i) = (1); (i) <= (n); ++(i))
    for ((j) = (1); (j) <= (n); ++(j))
      if (g[i][j] == 1 && can[i][j] == 1) work2(i, j);
  Dp2(f_After, After);
  for ((i) = (1); (i) <= (n); ++(i))
    for ((j) = (1); (j) <= (n); ++(j))
      if (g[i][j] == 1 && can[i][j] == 1) check(i, j);
  for ((i) = (1); (i) <= (2 * n); ++(i)) cout << ans[i] << endl;
  return 0;
}