There are N cards placed face down in a row. On each card, an integer 1 or 2 is written.

Let A_i be the integer written on the i-th card.

Your objective is to guess A_1, A_2, ..., A_N correctly.

You know the following facts:

* For each i = 1, 2, ..., M, the value A_{X_i} + A_{Y_i} + Z_i is an even number.



You are a magician and can use the following magic any number of times:

Magic: Choose one card and know the integer A_i written on it. The cost of using this magic is 1.

What is the minimum cost required to determine all of A_1, A_2, ..., A_N?

It is guaranteed that there is no contradiction in given input.

Constraints

* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq X_i < Y_i \leq N
* 1 \leq Z_i \leq 100
* The pairs (X_i, Y_i) are distinct.
* There is no contradiction in input. (That is, there exist integers A_1, A_2, ..., A_N that satisfy the conditions.)

Input

Input is given from Standard Input in the following format:


N M
X_1 Y_1 Z_1
X_2 Y_2 Z_2
\vdots
X_M Y_M Z_M


Output

Print the minimum total cost required to determine all of A_1, A_2, ..., A_N.

Examples

Input

3 1
1 2 1


Output

2


Input

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


Output

2


Input

100000 1
1 100000 100


Output

99999
import java.util.*;

public class Main {

  public static void main(String args[]) {
    int rep = 1;
    if( args.length > 0 ) { rep = Integer.parseInt(args[0]); }
    (new Main()).__solve(rep);
  }

  void __solve(int rep) {

    try (
      Scanner cin = new Scanner(System.in);
    ) {

      for( int i = 0; i < rep; ++i ) {
        __solve(cin);
      }

    }

  }

  void __solve(Scanner cin) {
	  int N = cin.nextInt();
	  int M = cin.nextInt();
	  UnionFind uf = new UnionFind(N);
	  for( int i = 0; i < M; ++i ) {
		  int a = cin.nextInt() - 1;
		  int b = cin.nextInt() - 1;
		  int z = cin.nextInt();
		  uf.merge(a, b);
	  }
	  System.out.println(uf.numGroups());
  }

  class UnionFind {

	  private static final boolean ufDebug = false;
	  private static final int ROOT = -1;

	  private int group[];
	  private int size;
	  private int rest;

	  private int count[];
	  
	  public int numGroups() {
		  int ret = 0;
		  for( int i = 0; i < size; ++i ) {
			  if( group[i] == ROOT ) { ++ret; }
		  }
		  return ret;
	  }

	  public UnionFind(int N) {
	    size = rest = N;
	    group = new int[size];
	    for(int i=0; i<N; ++i) { group[i] = ROOT; }
	    count = new int[size];
	  }

	  public int size() {
	    return rest;
	  }

	  public int find(int index) {
	    if( index < 0 || index >= size ) { return -1; }
	    int ret = index;
	    while( group[ret] != ROOT ) { ret = group[ret]; }
	    return ret;
	  }

	  public boolean same(int a, int b) {
	    return find(a) == find(b);
	  }

	  public void merge(int a, int b) {
	    int A = find(a);
	    int B = find(b);
	    if( A == B ) { return; }
	    if( count[A] <= count[B] ) { subMerge(A, B); }
	    else { subMerge(B, A); }
	  }

	  // merge A (small) into B (large)
	  private void subMerge(int A, int B) {
	    if( group[A] != ROOT || group[B] != ROOT ) {
	      if( ufDebug ) { throw new RuntimeException("Implementation Error !"); }
	      return;
	    }
	    group[A] = B;
	    count[B] += count[A] + 1;
	    --rest;
	  }

	}

  
}
