Problem: Berland has n cities, some of which are connected by roads. Each road is bidirectional, connects two distinct cities and for each two cities there's at most one road connecting them.

The president of Berland decided to split country into r states in such a way that each city will belong to exactly one of these r states.

After this split each road will connect either cities of the same state or cities of the different states. Let's call roads that connect two cities of the same state "inner" roads.

The president doesn't like odd people, odd cities and odd numbers, so he wants this split to be done in such a way that each city would have even number of "inner" roads connected to it.

Please help president to find smallest possible r for which such a split exists.

Input

The input contains one or several test cases. The first input line contains a single integer number t — number of test cases. Then, t test cases follow. Solve test cases separately, test cases are completely independent and do not affect each other.

Then t blocks of input data follow. Each block starts from empty line which separates it from the remaining input data. The second line of each block contains two space-separated integers n, m (1 ≤ n ≤ 2000, 0 ≤ m ≤ 10000) — the number of cities and number of roads in the Berland. Each of the next m lines contains two space-separated integers — x_i, y_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i), which denotes that the i-th road connects cities x_i and y_i. Each pair of cities are connected by at most one road. 

Sum of values n across all test cases doesn't exceed 2000. Sum of values m across all test cases doesn't exceed 10000.

Output

For each test case first print a line containing a single integer r — smallest possible number of states for which required split is possible. In the next line print n space-separated integers in range from 1 to r, inclusive, where the j-th number denotes number of state for the j-th city. If there are multiple solutions, print any.

Example

Input

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


Output

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

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const signed long long llf = (signed long long)(~0ull >> 1);
const signed int inf = (signed)(~0u >> 1);
template <typename T>
T __abs(T x) {
  return (x < 0) ? (-x) : (x);
}
template <typename T>
void pfill(T* pst, const T* ped, T val) {
  for (; pst != ped; *(pst++) = val)
    ;
}
template <typename T>
void pcopy(T* pst, const T* ped, T* pv) {
  for (; pst != ped; *(pst++) = *(pv++))
    ;
}
const int N = 2048;
int n, m;
bool deg[N];
bitset<N> eq[N];
void reverse(bitset<N>& bs, int bit) {
  if (bs.test(bit))
    bs.reset(bit);
  else
    bs.set(bit);
}
inline void init() {
  scanf("%d%d", &n, &m);
  pfill(deg, deg + n, false);
  for (int i = 0; i < n; i++) eq[i].reset();
  for (int i = 1, u, v; i <= m; i++) {
    scanf("%d%d", &u, &v);
    u--, v--;
    eq[u].set(v);
    eq[v].set(u);
    reverse(eq[u], u);
    reverse(eq[v], v);
    deg[u] = !deg[u], deg[v] = !deg[v];
  }
}
void guass() {
  for (int i = 0; i < n; i++) {
    int p = -1;
    for (int j = i; j < n && p == -1; j++)
      if (eq[j].test(i)) p = j;
    if (p == -1) continue;
    swap(eq[p], eq[i]);
    swap(deg[p], deg[i]);
    for (int j = 0; j < n; j++)
      if ((j ^ i) && eq[j].test(i)) eq[j] ^= eq[i], deg[j] ^= deg[i];
  }
}
inline void solve() {
  guass();
  int r = 1;
  for (int i = 0; i < n && r == 1; i++)
    if (deg[i]) r = 2;
  printf("%d\n", r);
  for (int i = 0; i < n; i++) printf("%d ", deg[i] + 1);
  puts("");
}
int T;
int main() {
  scanf("%d", &T);
  while (T--) {
    init();
    solve();
  }
  return 0;
}