On her way to programming school tiger Dasha faced her first test — a huge staircase!

<image>

The steps were numbered from one to infinity. As we know, tigers are very fond of all striped things, it is possible that it has something to do with their color. So on some interval of her way she calculated two values — the number of steps with even and odd numbers. 

You need to check whether there is an interval of steps from the l-th to the r-th (1 ≤ l ≤ r), for which values that Dasha has found are correct.

Input

In the only line you are given two integers a, b (0 ≤ a, b ≤ 100) — the number of even and odd steps, accordingly.

Output

In the only line print "YES", if the interval of steps described above exists, and "NO" otherwise.

Examples

Input

2 3


Output

YES


Input

3 1


Output

NO

Note

In the first example one of suitable intervals is from 1 to 5. The interval contains two even steps — 2 and 4, and three odd: 1, 3 and 5.
import java.util.*;

import java.io.*;

public class A {
	public static void main(String[] args) {
		new A().solve();
	}

	FasterScanner in = new FasterScanner();
	PrintWriter out = new PrintWriter(System.out);

	long mod = (long) 1e9 + 7;

	public void solve() {
//		int tt = in.nextInt();
//		for(int ii=0;ii<tt;ii++) {
		int a= in.nextInt();
		int b= in.nextInt();
		int x = Math.abs(a-b);
		if (a==0 && b ==0) {
			out.println("NO");
		}
		else if(x<=1) {
			out.println("YES");
		} else {
			out.println("NO");
		}
//	}
//		}
		out.close();
	}
	
	long[] sum;
	
	public long func(int step, long idx) {
		//System.out.println(step + " " + idx);
		if(sum[step-1] + 1 == idx) {
			return step + 1;
		} else if(idx<=sum[step-1]) {
			return func(step-1, idx);
		} else {
			return func(step-1,idx-sum[step-1]-1);
		}
	}

	public static long[][] matrixAdd(long[][] a, long[][] b) {
		int n = a.length;
		int m = a[0].length;
		long[][] res = new long[n][m];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				res[i][j] = a[i][j] + b[i][j];
			}
		}
		return res;
	}

	public static long[][] matrixMul(long[][] a, long[][] b, long mod) {
		int n = a.length;
		int m = a[0].length;
		int k = b[0].length;
		long[][] res = new long[n][k];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < k; j++) {
				for (int p = 0; p < m; p++) {
					res[i][j] = (res[i][j] + (a[i][p] %mod* b[p][j]) % mod) % mod;
				}
			}
		}
		return res;
	}

	public static long[][] matrixPow(long[][] a, long p, long mod) {
		if (p == 0) {
			return matrixUnit(a.length);
		} else if (p % 2 == 0) {
			return matrixPow(matrixMul(a, a, mod), p / 2, mod);
		} else {
			return matrixMul(a, matrixPow(a, p - 1, mod), mod);
		}
	}

	public static long[][] matrixUnit(int n) {
		long[][] res = new long[n][n];
		for (int i = 0; i < n; ++i) {
			res[i][i] = 1;
		}
		return res;
	}

	public static long gcd(long a, long b) {
		return b == 0 ? Math.abs(a) : gcd(b, a % b);
	}

	public static long gcd2(long a, long b) {
		while (b != 0) {
			long t = b;
			b = a % b;
			a = t;
		}
		return Math.abs(a);
	}

	public static long lcm(long a, long b) {
		return Math.abs(a / gcd(a, b) * b);
	}

	class S implements Comparable<S> {
		long val;
		int idx;

		public S(long val, int idx) {
			this.val = val;
			this.idx = idx;
		}

		@Override
		public int compareTo(S o) {
			// TODO Auto-generated method stub
			if (this.val != o.val) {
				return Long.compare(this.val, o.val);
			} else {
				return Integer.compare(this.idx, o.idx);
			}
		}

	}

	long pow(long a, long n, long m) {
		if (n == 1)
			return a;
		if (n == 0)
			return 1;
		long ans = pow(a, n / 2, m);
		ans *= ans;
		ans %= m;
		if (n % 2 != 0)
			ans *= a;
		ans %= m;
		return ans;
	}

	public static void shortestPaths(List<Edge>[] edges, int s, int[] prio, int[] pred) {
		Arrays.fill(pred, -1);
		Arrays.fill(prio, Integer.MAX_VALUE);
		prio[s] = 0;
		PriorityQueue<Long> q = new PriorityQueue<>();
		q.add((long) s);
		while (!q.isEmpty()) {
			long cur = q.remove();
			int curu = (int) cur;
			if (cur >>> 32 != prio[curu])
				continue;
			for (Edge e : edges[curu]) {
				int v = e.t;
				int nprio = prio[curu] + e.cost;
				if (prio[v] > nprio) {
					prio[v] = nprio;
					pred[v] = curu;
					q.add(((long) nprio << 32) + v);
				}
			}
		}
	}

	class Edge {
		int t, cost;

		public Edge(int t, int cost) {
			this.t = t;
			this.cost = cost;
		}
	}

	// class Edge {
	// Node next;
	// int w;
	//
	// public Edge(Node n, int w) {
	// this.next = n;
	// this.w = w;
	// }
	// }
	//
	// class Node implements Comparable<Node> {
	// ArrayList<Edge> next = new ArrayList<Edge>();
	// int w = Integer.MAX_VALUE;
	// int idx;
	//
	// public Node(int i) {
	// this.idx = i;
	// }
	//
	// public int compareTo(Node n) {
	// if (this.w != n.w) {
	// return Integer.compare(this.w, n.w);
	// } else {
	// return Integer.compare(this.idx, n.idx);
	// }
	// }
	// }

	public static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = System.in.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == '\n' || c == '\r' || c == -1 || c == ' ' || c == '\t';
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}

			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public double nextDouble() {
			return Double.parseDouble(nextString());
		}

		public int[] nextIntArray(int n) {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public int[] nextIntArray10(int n) {
			int[] arr = new int[n + 1];
			for (int i = 1; i <= n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray10(int n) {
			long[] arr = new long[n + 1];
			for (int i = 1; i <= n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public int[] nextIntArray11(int n) {
			int[] arr = new int[n + 2];
			for (int i = 1; i <= n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray11(int n) {
			long[] arr = new long[n + 2];
			for (int i = 1; i <= n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}
	}

}