Problem: There are N people standing on the x-axis. Let the coordinate of Person i be x_i. For every i, x_i is an integer between 0 and 10^9 (inclusive). It is possible that more than one person is standing at the same coordinate.

You will given M pieces of information regarding the positions of these people. The i-th piece of information has the form (L_i, R_i, D_i). This means that Person R_i is to the right of Person L_i by D_i units of distance, that is, x_{R_i} - x_{L_i} = D_i holds.

It turns out that some of these M pieces of information may be incorrect. Determine if there exists a set of values (x_1, x_2, ..., x_N) that is consistent with the given pieces of information.

Constraints

* 1 \leq N \leq 100 000
* 0 \leq M \leq 200 000
* 1 \leq L_i, R_i \leq N (1 \leq i \leq M)
* 0 \leq D_i \leq 10 000 (1 \leq i \leq M)
* L_i \neq R_i (1 \leq i \leq M)
* If i \neq j, then (L_i, R_i) \neq (L_j, R_j) and (L_i, R_i) \neq (R_j, L_j).
* D_i are integers.

Input

Input is given from Standard Input in the following format:


N M
L_1 R_1 D_1
L_2 R_2 D_2
:
L_M R_M D_M


Output

If there exists a set of values (x_1, x_2, ..., x_N) that is consistent with all given pieces of information, print `Yes`; if it does not exist, print `No`.

Examples

Input

3 3
1 2 1
2 3 1
1 3 2


Output

Yes


Input

3 3
1 2 1
2 3 1
1 3 5


Output

No


Input

4 3
2 1 1
2 3 5
3 4 2


Output

Yes


Input

10 3
8 7 100
7 9 100
9 8 100


Output

No


Input

100 0


Output

Yes

Solution (in JAVA):

Solution:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static int N = 0;
	static int M = 0;
	static int[] L = null;
	static int[] R = null;
	static int[] D = null;

	static ArrayList<Integer>[] LL = null;
	static ArrayList<Integer>[] RR = null;

	static boolean[] check = null;
	static long[] x = null;
	static boolean[] visited = null;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		L = new int[M];
		R = new int[M];
		D = new int[M];

		LL = new ArrayList[N + 1];
		RR = new ArrayList[N + 1];
		for (int i = 0; i < M; i++) {
			L[i] = sc.nextInt();
			R[i] = sc.nextInt();
			D[i] = sc.nextInt();

			if (LL[L[i]] == null) {
				LL[L[i]] = new ArrayList<Integer>();
			}
			LL[L[i]].add(i);
			if (RR[R[i]] == null) {
				RR[R[i]] = new ArrayList<Integer>();
			}
			RR[R[i]].add(i);
		}

		check = new boolean[M];
		Arrays.fill(check, false);
		x = new long[N + 1];
		Arrays.fill(x, 0L);
		visited = new boolean[N + 1];
		Arrays.fill(visited, false);
		boolean ans = true;
		for (int i = 0; i < M; i++) {
			if (check[i]) {
				continue;
			}
			x[L[i]] = 0L;
			x[R[i]] = D[i];
			visited[L[i]] = true;
			visited[R[i]] = true;
			check[i] = true;
			ans &= rec(i, true, true);
			if (!ans) {
				break;
			}
		}
		if (ans) {
			System.out.println("Yes");
		} else {
			System.out.println("No");
		}
	}

	static boolean rec(int i, boolean lcheck, boolean rcheck) {
		// Li
		if (LL[L[i]] != null && lcheck) {
			for (int j : LL[L[i]]) {
				if (check[j]) {
					continue;
				}
				check[j] = true;
				if (visited[R[j]]) {
					if (x[R[j]] - x[L[j]] != D[j]) {
						return false;
					}
				} else {
					visited[R[j]] = true;
					x[R[j]] = x[L[j]] + D[j];
					if (!rec(j, false, true)) {
						return false;
					}
				}
			}
		}
		if (RR[L[i]] != null && lcheck) {
			for (int j : RR[L[i]]) {
				if (check[j]) {
					continue;
				}
				check[j] = true;
				if (visited[L[j]]) {
					if (x[R[j]] - x[L[j]] != D[j]) {
						return false;
					}
				} else {
					visited[L[j]] = true;
					x[L[j]] = x[R[j]] - D[j];
					if (!rec(j, true, false)) {
						return false;
					}
				}
			}
		}

		// Ri
		if (LL[R[i]] != null && rcheck) {
			for (int j : LL[R[i]]) {
				if (check[j]) {
					continue;
				}
				check[j] = true;
				if (visited[R[j]]) {
					if (x[R[j]] - x[L[j]] != D[j]) {
						return false;
					}
				} else {
					visited[R[j]] = true;
					x[R[j]] = x[L[j]] + D[j];
					if (!rec(j, false, true)) {
						return false;
					}
				}
			}
		}
		if (RR[R[i]] != null && rcheck) {
			for (int j : RR[R[i]]) {
				if (check[j]) {
					continue;
				}
				check[j] = true;
				if (visited[L[j]]) {
					if (x[R[j]] - x[L[j]] != D[j]) {
						return false;
					}
				} else {
					visited[L[j]] = true;
					x[L[j]] = x[R[j]] - D[j];
					if (!rec(j, true, false)) {
						return false;
					}
				}
			}
		}
		return true;
	}
}