794_D. Labelling Cities_33202
Oleg the bank client lives in Bankopolia. There are n cities in Bankopolia and some pair of cities are connected directly by bi-directional roads. The cities are numbered from 1 to n. There are a total of m roads in Bankopolia, the i-th road connects cities ui and vi. It is guaranteed that from each city it is possible to travel to any other city using some of the roads.

Oleg wants to give a label to each city. Suppose the label of city i is equal to xi. Then, it must hold that for all pairs of cities (u, v) the condition |xu - xv| ≤ 1 holds if and only if there is a road connecting u and v.

Oleg wonders if such a labeling is possible. Find an example of such labeling if the task is possible and state that it is impossible otherwise.

Input

The first line of input contains two space-separated integers n and m (2 ≤ n ≤ 3·105, 1 ≤ m ≤ 3·105) — the number of cities and the number of roads.

Next, m lines follow. The i-th line contains two space-separated integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the cities connected by the i-th road. It is guaranteed that there is at most one road between each pair of cities and it is possible to travel from any city to any other city using some roads.

Output

If the required labeling is not possible, output a single line containing the string "NO" (without quotes).

Otherwise, output the string "YES" (without quotes) on the first line. On the next line, output n space-separated integers, x1, x2, ..., xn. The condition 1 ≤ xi ≤ 109 must hold for all i, and for all pairs of cities (u, v) the condition |xu - xv| ≤ 1 must hold if and only if there is a road connecting u and v.

Examples

Input

4 4
1 2
1 3
1 4
3 4


Output

YES
2 3 1 1 


Input

5 10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
5 4


Output

YES
1 1 1 1 1 


Input

4 3
1 2
1 3
1 4


Output

NO

Note

For the first sample, x1 = 2, x2 = 3, x3 = x4 = 1 is a valid labeling. Indeed, (3, 4), (1, 2), (1, 3), (1, 4) are the only pairs of cities with difference of labels not greater than 1, and these are precisely the roads of Bankopolia.

For the second sample, all pairs of cities have difference of labels not greater than 1 and all pairs of cities have a road connecting them.

For the last sample, it is impossible to construct a labeling satisfying the given constraints.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Set;
import java.util.HashMap;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.Map;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskD {
		public void solve(int testNumber, FastScanner in, PrintWriter out) {
			int n = in.nextInt();
			int m = in.nextInt();
			int[] edgeA = new int[m];
			int[] edgeB = new int[m];
			for (int i = 0; i < m; i++) {
				edgeA[i] = in.nextInt() - 1;
				edgeB[i] = in.nextInt() - 1;
			}

			int[][] adj = parseGraphAndAddLoops(n, edgeA, edgeB);
			Map<AdjList, Integer> map = new HashMap<>();
			for (int[] arr : adj) {
				AdjList l = new AdjList(arr);
				if (!map.containsKey(l)) {
					int id = map.size();
					map.put(l, id);
				}
			}

			int[] id = new int[n];
			for (int i = 0; i < n; i++) {
				id[i] = map.get(new AdjList(adj[i]));
			}

			int numComps = map.size();
			Set<Integer>[] adjComp = new Set[numComps];
			for (int i = 0; i < adjComp.length; i++) {
				adjComp[i] = new HashSet<>();
			}

			for (int i = 0; i < m; i++) {
				int a = id[edgeA[i]];
				int b = id[edgeB[i]];
				if (a != b) {
					adjComp[a].add(b);
					adjComp[b].add(a);
				}
			}

			int s = -1;
			for (int i = 0; i < numComps; i++) {
				if (adjComp[i].size() > 2) {
					out.println("NO");
					return;
				}
				if (adjComp[i].size() == 1) {
					s = i;
				}
			}
			if (numComps > 1 && s < 0) {
				out.println("NO");
				return;
			}

			// A path of comps.
			int[] compLevel = new int[numComps];
			if (s >= 0) {
				dfs(s, -1, adjComp, compLevel);
			}

			out.println("YES");
			for (int i = 0; i < n; i++) {
				if (i > 0) {
					out.print(" ");
				}
				out.print(compLevel[id[i]] + 1);
			}
			out.println();
		}

		private void dfs(int v, int p, Set<Integer>[] adjComp, int[] compLevel) {
			for (int u : adjComp[v]) {
				if (u != p) {
					compLevel[u] = 1 + compLevel[v];
					dfs(u, v, adjComp, compLevel);
				}
			}
		}

		private int[][] parseGraphAndAddLoops(int n, int[] as, int[] bs) {
			int[] deg = new int[n];
			Arrays.fill(deg, 1);
			for (int i = 0; i < as.length; i++) {
				++deg[as[i]];
				++deg[bs[i]];
			}
			int[][] adj = new int[n][];
			for (int i = 0; i < n; i++) {
				adj[i] = new int[deg[i]];
			}
			for (int i = 0; i < as.length; i++) {
				int a = as[i];
				int b = bs[i];
				adj[a][--deg[a]] = b;
				adj[b][--deg[b]] = a;
			}
			for (int i = 0; i < n; i++) {
				adj[i][--deg[i]] = i;
			}
			for (int[] arr : adj) {
				Arrays.sort(arr);
			}
			return adj;
		}

		class AdjList {
			int[] a;

			AdjList(int[] a) {
				this.a = a;
			}

			public boolean equals(Object obj) {
				AdjList o = (AdjList) obj;
				return Arrays.equals(a, o.a);
			}

			public int hashCode() {
				return Arrays.hashCode(a);
			}

		}

	}

	static class FastScanner {
		private BufferedReader in;
		private StringTokenizer st;

		public FastScanner(InputStream stream) {
			in = new BufferedReader(new InputStreamReader(stream));
		}

		public String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					String rl = in.readLine();
					if (rl == null) {
						return null;
					}
					st = new StringTokenizer(rl);
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return st.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

	}
}

