Problem: Welcome to the world of Pokermon, yellow little mouse-like creatures, who absolutely love playing poker! 

Yeah, right… 

In the ensuing Pokermon League, there are n registered Pokermon trainers, and t existing trainer teams each of which belongs to one of two conferences. Since there is a lot of jealousy between trainers, there are e pairs of trainers who hate each other. Their hate is mutual, there are no identical pairs among these, and no trainer hates himself (the world of Pokermon is a joyful place!). Each trainer has a wish-list of length li of teams he’d like to join.

Your task is to divide players into teams and the teams into two conferences, so that: 

  * each trainer belongs to exactly one team; 
  * no team is in both conferences; 
  * total hate between conferences is at least e / 2; 
  * every trainer is in a team from his wish-list. 



Total hate between conferences is calculated as the number of pairs of trainers from teams from different conferences who hate each other. 

Input

The first line of the input contains two integer n (4 ≤ n ≤ 50 000) and e (2 ≤ e ≤ 100 000) — the total number of Pokermon trainers and the number of pairs of trainers who hate each other.

Pokermon trainers are numbered from 1 to n. Next e lines contain two integers a and b (1 ≤ a, b ≤ n) indicating that Pokermon trainers a and b hate each other. Next 2n lines are in a following format. Starting with Pokermon trainer 1, for each trainer in consecutive order: first number li (16 ≤ li ≤ 20) — a size of Pokermon trainers wish list, then li positive integers ti, j (1 ≤ ti, j ≤ T), providing the teams the i-th trainer would like to be on.

Each trainers wish list will contain each team no more than once. Teams on the wish lists are numbered in such a way that the set of all teams that appear on at least 1 wish list is set of consecutive positive integers {1, 2, 3, …, T}. Here T might be up to 1 000 000.

Output

Print two lines. The first line should contain n numbers, specifying for each trainer the team he is in.

The second line should contain T numbers, specifying the conference for each team (1 or 2).

Example

Input

4 3
1 2
2 3
4 1
16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 16 15
16
2 3 4 5 6 7 8 9 10 11 12 13 14 15 17 18
16
2 3 4 5 6 7 8 9 10 11 12 13 14 15 18 19
16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 16 19


Output

16 15 19 14 
2 2 2 1 1 1 2 1 1 2 1 1 1 2 2 1 1 1 1 

Note

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long power(long long x, long long y) {
  long long t = 1;
  while (y > 0) {
    if (y % 2)
      y -= 1, t = t * x % mod;
    else
      y /= 2, x = x * x % mod;
  }
  return t;
}
vector<int> G[N], L[N], P[N], Nx[N];
pair<int, int> edges[N];
int grp[N], team[N], nos[N];
int tl = 0;
int n, e;
vector<int> perm, tms;
bool trymybest() {
  for (int i = 0; i < n; ++i) {
    int x = rand() % L[i].size();
    grp[i] = L[i][x];
  }
  int itr = 10;
  while (itr--) {
    random_shuffle(perm.begin(), perm.end());
    for (int i = 0; i < n; ++i) {
      int v = perm[i];
      for (int j = 0; j < P[v].size(); ++j) P[v][j] = 0;
      for (int j = 0; j < G[v].size(); ++j) {
        int x =
            lower_bound(L[v].begin(), L[v].end(), grp[G[v][j]]) - L[v].begin();
        if (x < L[v].size()) {
          P[v][x]++;
        }
      }
      int x = lower_bound(L[v].begin(), L[v].end(), grp[v]) - L[v].begin();
      for (int j = 0; j < P[v].size(); ++j) {
        if (P[v][x] > P[v][j]) x = j;
      }
      grp[v] = L[v][x];
    }
  }
  memset(nos, 0, sizeof(nos));
  for (int i = 0; i < tl; ++i) Nx[i].clear();
  for (int i = 0; i < n; ++i) team[i] = rand() & 1;
  for (int i = 0; i < e; ++i) {
    int t1 = grp[edges[i].first], t2 = grp[edges[i].second];
    if (t1 != t2) {
      Nx[t1].push_back(t2);
      Nx[t2].push_back(t1);
    }
  }
  itr = 10;
  while (itr--) {
    random_shuffle(tms.begin(), tms.end());
    for (int i = 0; i < tl; ++i) {
      int te = tms[i];
      int ap[2];
      ap[0] = ap[1] = 0;
      for (int j = 0; j < Nx[te].size(); ++j) {
        ap[team[Nx[te][j]]]++;
      }
      if (ap[team[te]] > ap[team[te] ^ 1]) team[te] ^= 1;
    }
  }
  itr = 10;
  while (itr--) {
    random_shuffle(perm.begin(), perm.end());
    for (int i = 0; i < n; ++i) {
      int v = perm[i];
      int ap[2];
      ap[0] = ap[1] = 0;
      for (int j = 0; j < G[v].size(); ++j) {
        ap[team[grp[G[v][j]]]]++;
      }
      if (ap[team[grp[v]]] > ap[team[grp[v]] ^ 1]) {
        for (int j = 0; j < L[v].size(); ++j)
          if (team[L[v][j]] = team[grp[v]] ^ 1) {
            grp[v] = L[v][j];
            break;
          }
      }
    }
  }
  int tot = 0;
  for (int i = 0; i < e; ++i) {
    int t1 = team[grp[edges[i].first]], t2 = team[grp[edges[i].second]];
    if (t1 != t2) tot++;
  }
  return tot > e / 2;
}
int main() {
  srand(time(NULL));
  scanf("%d%d", &n, &e);
  for (int i = 0; i < e; ++i) {
    int x, y;
    scanf("%d%d", &x, &y);
    x--;
    y--;
    edges[i] = make_pair(x, y);
    G[x].push_back(y);
    G[y].push_back(x);
  }
  for (int i = 0; i < n; ++i) {
    int l;
    scanf("%d", &l);
    for (int j = 0; j < l; ++j) {
      int x;
      scanf("%d", &x);
      tl = max(tl, x);
      L[i].push_back(x - 1);
    }
    sort(L[i].begin(), L[i].end());
    P[i].resize(L[i].size());
  }
  perm.resize(n);
  tms.resize(tl);
  for (int i = 0; i < n; ++i) perm[i] = i;
  for (int i = 0; i < tl; ++i) tms[i] = i;
  int tot = 0;
  assert(trymybest() == 1);
  for (int i = 0; i < n; ++i) printf("%d ", grp[i] + 1);
  printf("\n");
  for (int i = 0; i < tl; ++i) printf("%d ", team[i] + 1);
  printf("\n");
  return 0;
}