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.*;

class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int M = sc.nextInt();
		int[] X = new int[M];
		int[] Y = new int[M];
		int[] Z = new int[M];
		for (int i=0;i<M;i++) {
			X[i]=sc.nextInt();
			Y[i]=sc.nextInt();
			Z[i]=sc.nextInt();
		}
		UnionFind uni = new UnionFind(N);
		for (int i=0;i<M;i++) {
			uni.connect(X[i]-1,Y[i]-1);
		}
		int ans=0;
		for (int i=0;i<N;i++) {
			if (uni.Parent.get(i)<0) {
				ans++;
			}
		}
		System.out.println(ans);
	}
}

class UnionFind {
	List<Integer> Parent;
	UnionFind(int N) {
		Parent = new ArrayList<Integer>();
		Integer[] values = new Integer[N];
		Arrays.fill(values, -1);
		Parent.addAll(Arrays.asList(values));
	}
	int root(int A) {
		if (Parent.get(A) < 0)
			return A;
		int root = root(Parent.get(A));
		Parent.set(A, root);
		return root;
	}
	int size(int A) {
		return -Parent.get(root(A));
	}

	boolean connect(int A, int B) {
		A = root(A);
		B = root(B);
		if (A == B) {
			return false;
		}

		if (size(A) < size(B)) {
			int temp = A;
			A = B;
			B = temp;
		}

		Parent.set(A, Parent.get(A) + Parent.get(B));
		Parent.set(B, A);

		return true;
	}
}