Problem: BubbleSquare social network is celebrating 13^{th} anniversary and it is rewarding its members with special edition BubbleSquare tokens. Every member receives one personal token. Also, two additional tokens are awarded to each member for every friend they have on the network. Yet, there is a twist – everyone should end up with different number of tokens from all their friends. Each member may return one received token. Also, each two friends may agree to each return one or two tokens they have obtained on behalf of their friendship.

Input

First line of input contains two integer numbers n and k (2 ≤ n ≤ 12500, 1 ≤ k ≤ 1000000) - number of members in network and number of friendships.

Next k lines contain two integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) - meaning members a_i and b_i are friends.

Output

First line of output should specify the number of members who are keeping their personal token.

The second line should contain space separated list of members who are keeping their personal token.

Each of the following k lines should contain three space separated numbers, representing friend pairs and number of tokens each of them gets on behalf of their friendship.

Examples

Input


2 1
1 2


Output


1
1 
1 2 0


Input


3 3
1 2
1 3
2 3


Output


0
1 2 0
2 3 1
1 3 2

Note

In the first test case, only the first member will keep its personal token and no tokens will be awarded for friendship between the first and the second member.

In the second test case, none of the members will keep their personal token. The first member will receive two tokens (for friendship with the third member), the second member will receive one token (for friendship with the third member) and the third member will receive three tokens (for friendships with the first and the second member).

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, m;
  scanf("%i %i", &n, &m);
  vector<vector<int> > graf(n);
  vector<int> par(n), coins(n);
  for (int i = 0; i < m; i++) {
    int u, v;
    scanf("%i %i", &u, &v);
    u--;
    v--;
    graf[max(u, v)].push_back(min(u, v));
    coins[u]++;
    coins[v]++;
  }
  vector<pair<pair<int, int>, int> > edgeSol;
  for (int i = 0; i < n; i++) {
    map<int, int> taken;
    vector<int> up, down;
    for (auto p : graf[i]) {
      taken[coins[p]] = 1;
      if (par[p])
        up.push_back(p);
      else
        down.push_back(p);
    }
    if (!taken[coins[i]]) {
      for (auto p : up) edgeSol.push_back({{p, i}, 1});
      for (auto p : down) edgeSol.push_back({{p, i}, 1});
      continue;
    }
    bool nasao = 0;
    for (int j = 1; j <= up.size(); j++) {
      if (!taken[coins[i] + j]) {
        coins[i] += j;
        for (auto p : down) edgeSol.push_back({{p, i}, 1});
        for (int k = 0; k < up.size(); k++) {
          if (k < j)
            edgeSol.push_back({{up[k], i}, 2}), par[up[k]] ^= 1;
          else
            edgeSol.push_back({{up[k], i}, 1});
        }
        nasao = 1;
        break;
      }
    }
    if (!nasao) {
      for (int j = 1; j <= down.size(); j++) {
        if (!taken[coins[i] - j]) {
          coins[i] -= j;
          for (auto p : up) edgeSol.push_back({{p, i}, 1});
          for (int k = 0; k < down.size(); k++) {
            if (k < j)
              edgeSol.push_back({{down[k], i}, 0}), par[down[k]] ^= 1;
            else
              edgeSol.push_back({{down[k], i}, 1});
          }
          nasao = 1;
          break;
        }
      }
    }
    assert(nasao);
  }
  vector<int> lst;
  for (int i = 0; i < n; i++)
    if (par[i]) lst.push_back(i);
  printf("%i ", lst.size());
  for (auto p : lst) printf("%i ", p + 1);
  printf("\n");
  for (auto p : edgeSol)
    printf("%i %i %i\n", p.first.first + 1, p.first.second + 1, p.second);
  return 0;
}