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.math.*;
                    import java.io.*;
                    import java.text.DecimalFormat;
                    import java.math.BigInteger;
                    public class Main{
                        //static int d=20;
                        static long mod=1000000007 ;
                        static HashMap<String,Double> hm=new HashMap<>(); 
                        static ArrayList<ArrayList<Integer>> arr;
                        static long[] dp1,dp2;
                        static int[] a;
                        static int[] vis,num;
                        static long max;
                        static int id;
                        public static void main(String[] args)  throws IOException {
                            boolean online =false;
                            String fileName = "C-large-practice";
                            PrintWriter out; 
                            if (online) {
                                s.init(new FileInputStream(new File(fileName + ".in")));
                                 out= new PrintWriter(new FileWriter(fileName + "out.txt"));
                            }
                             else {
                                s.init(System.in);   
                            
                                out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
                            }//r,b,y,g
                            int a,b;
                            a=s.ni();
                            b=s.ni();
                            if(a==0 && b==0)
                                out.println("NO");
                            else if(Math.abs(a-b)<=1)
                                out.println("YES");
                            else
                                out.println("NO");
                            out.close();
             
                        }
                        static class query implements Comparable<query> {
                            int l,r,k,id;
                            public query(int a,int b,int c,int d){
                                {   id=a;
                                    l=b;
                                    r=c;
                                    k=d;
                                }
                                
                                
                                
                            }
                            public int compareTo(query o){
                                return o.k-k;
                            }
                            
                        }
                        public static void dfs2(HashSet<Integer> hs,int x,int[] vis2,ArrayList<ArrayList<Integer>> arr2){
                            vis2[x]=1;
                            hs.add(x);
                            ArrayList<Integer> arr3=arr2.get(x);
                            for(int z:arr3){
                                if(vis2[z]==0)
                                    dfs2(hs,z,vis2,arr2);
                            }
                            //st.push(x);

                        }
                        
                        public static void dfs(int x,int[] vis,Stack<Integer> st){
                            vis[x]=1;
                            ArrayList<Integer> arr2=arr.get(x);
                            Collections.sort(arr2);
                            for(int i=arr2.size()-1;i>=0;i--){
                                int z=arr2.get(i);
                                if(vis[z]==0)
                                    dfs(z,vis,st);
                            }
                            st.push(x);

                        }
                        public static long gcd(long a, long b){
                                if (a == 0) return b;
                                return gcd(b % a, a);
                        }
                            
                        public static boolean check(long x){
                            if(x%4==0 || x%7==0 || x%11==0)
                                return true;
                            if(x<4 || x<7 || x<11)
                                return false;
                            if(x%2==0){
                                return check(x/2);
                            }
                            else
                                return check(x/2) && check((x+1)/2);
                        }
                        public static int angle(int x1,int x2,int x3,int y1,int y2,int y3){
                            long val=(y2-y1)*1L*(x3-x2)-(y3-y2)*1L*(x2-x1);
                            if(val<0)
                                return 1;
                            else if(val>0)
                                return -1;
                            else
                                return 0;
                        }
                        
                        static class BIT{
                        
                            int N;
                            long tree[];
                            
                            BIT(int N){
                                this.N = N;
                                tree = new long[N + 1];
                            }
                            
                            void update(int idx,long val){
                                while(idx <= N){
                                    tree[idx]+=val;
                                    idx += (idx & -idx);
                                }
                            }
                            
                            long query(int l,int r){
                                if(l == 1)
                                    return read(r);
                                else
                                    return read(r) - read(l-1);
                            }
                            
                            long read(int idx){
                                long sum = 0;
                                while(idx > 0){
                                    sum += tree[idx];
                                    idx -= (idx & -idx);
                                }
                                return sum;
                            }
                        }
                        public static boolean pal(String a){
                            int i=0;
                            int j=a.length()-1;
                            while(i<j){
                                if(a.charAt(i)!=a.charAt(j)){
                                    return false;
                                }
                                i++;
                                j--;
                            }
                            return true;
                                
                        }
                        public static long find(long n,long k){
                            if(n==2){
                                if(k==1 || k==3)
                                    return 1;
                                else
                                    return 2;
                            }
                            long t=pow2(2,n,mod)-1;
                            long z=(t+1)/2;
                            if(k==z)
                                return n;
                            if(k<z)
                                return find(n-1,k);
                            else
                                return find(n-1,k-z);
                        }
                        public static long pow2(long a,long b,long mod){
                                long ans=1;
                                while(b>0){
                                    if(b%2==1)
                                        ans=(a*ans)%mod;
                                    a=(a*a)%mod;
                                    b/=2;
                                }
                                return  ans;
                        }
                        public static long pow3(long a,long b){
                                long ans=1;
                                while(b>0){
                                    if(b%2==1)
                                        ans=(a*ans);
                                    a=(a*a);
                                    b/=2;
                                }
                                return  ans;
                        }
             
                         static class name implements Comparable<name> {
                            long l,b,h;
                            public name(long   x,long y,long z){
                                {
                                    l=x;
                                    b=y;
                                }
                                
                                
                                h=z;
                            }
                            public int compareTo(name o){
                                return -(int)(l*b-o.l*o.b);
                            }
                            
                        }
                        public static class s {
                            static BufferedReader reader;
                            static StringTokenizer tokenizer;
                        
                            /** call this method to initialize reader for InputStream */
                            static void init(InputStream input) {
                                reader = new BufferedReader(
                                            new InputStreamReader(input) );
                                tokenizer = new StringTokenizer("");
                            }   
                        
                            /** get next word */
                            static String ns() throws IOException {
                                while ( ! tokenizer.hasMoreTokens() ) {
                                    //TODO add check for eof if necessary
                                    tokenizer = new StringTokenizer(
                                        reader.readLine() );
                                }
                                return tokenizer.nextToken();
                            }
                        
                            static int ni() throws IOException {
                                return Integer.parseInt( ns() );
                            }
                        
                            static double nd() throws IOException {
                                return Double.parseDouble( ns() );
                            }
                            static long nl() throws IOException {
                                return Long.parseLong( ns() );
                            }
                        }
                    }
                            