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

public class Main {

    private static Scanner in = new Scanner(System.in);

    public static void main(String[] args) {

        int a = in.nextInt();
        int b = in.nextInt();
        int min = Math.min(a,b);
        int max = Math.max(a,b);
        if(max-min == 1) System.out.println("YES");
        else {
            if(max==min && max!=0) System.out.println("YES");
            else System.out.println("NO");
        }
    }
    public boolean increasingTriplet(int[] nums) {
        boolean found = false;
        for (int i = 0; i < nums.length; i++) {

        }
        return false;
    }


    private static boolean check(int n) {
        int temp = (int)Math.sqrt(n);
        return Math.sqrt(n)==temp;
    }


    public String minWindow(String s, String t) {

        int [] mainFreq = frequency(t);

        int i = 0;
        int j = s.length() - 1;

        String ans = "";

        while (i<=j && i>=0 && j<s.length()) {
            String temp = s.substring(i,j+1);
            int [] freq = frequency(temp);
            boolean check = checkFrequencies(mainFreq,freq);
            if(check)  {
                ans = temp;
                i++;
            }
            else return ans;
        }

        while (i<=j && i>=0 && j<s.length()) {
            String temp = s.substring(i,j+1);
            int [] freq = frequency(temp);
            boolean check = checkFrequencies(mainFreq,freq);
            if(check)  {
                ans = temp;
                i++;
            }
            else return ans;
        }

        return "";
    }

    private static int [] frequency(String s) {
        int [] freq = new int[256];
        for (char c:s.toCharArray()) {
            freq[c-'a']++;
        }
        return freq;
    }

    private static boolean checkFrequencies(int [] freqA, int [] freqB) {
        for (int i = 0; i < freqA.length; i++) {
            if(freqB[i]<freqA[i] ) return  false;
        }
        return true;
    }


    static int lowerBound(int [] a, int target) {
        int lo = 0;
        int hi = a.length - 1;
        int ans = -1;

        while (lo<=hi) {
            int med = hi - (hi-lo)/2;
            if(target == a[med]){
                ans = med;
                hi = med - 1;
            }
            else if(target < a[med])  hi = med - 1;
            else lo = med + 1;
        }
        return ans;
    }

    static int upperBound(int [] a, int target) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo<=hi) {
            int med = hi-(hi-lo)/2;
            if(target>=a[med]) lo = med + 1;
            else hi = med - 1;
        }
        return hi;
    }
    static int solve(int n) {

        int side = (int)Math.sqrt(n);
        int small = side+side;

        if(side == Math.sqrt(n)) {
            return small;
        }

        int temp = n-side*side;

        if(temp % side == 0) {
           return small+=temp/side;
        }

        return small + temp/side + 1;
    }


    static boolean isPrime(int n) {
        if(n<=2) return false;
        for (int i = 2; i*i <=n ; i++) {
            if(n%i==0) return  false;
        }
        return  true;
    }

    static boolean check(char in, char out) {

        if(in=='{') {
            if(out==']' || out==')') return false;
            return true;
        }
        else if(in=='[') {
            if(out==')' || out == '}') return  false;
            return true;
        }

        if(out=='}' || out == '}') return false;
        return true;
    }

    static long solve(long k) {
        k= k*2;
        long d = 1+4*k;
        return (-1+(long)Math.sqrt(d))/2;
    }
    static int [] readAnArray(int n) {
        int [] a = new int[n];
        for (int i = 0; i < a.length; i++) {
            a[i] = in.nextInt();
        }
        return  a;
    }




    public List<String> topKFrequent(String[] words, int k) {

        Map<String,Integer> map = new HashMap<>();

        for (String word:words) {
            if(map.containsKey(word)) {
                int value = map.get(word);
                map.put(word,++value);
            }
            else {
                map.put(word,1);
            }
        }

        Word [] wordArray = new Word[map.size()];

        int i = 0;
        for (Map.Entry<String,Integer> entry : map.entrySet()) {
            wordArray[i++] = new Word(entry.getKey(),entry.getValue());
        }

        Arrays.sort(wordArray,new WordComparator());

        List<String> list = new ArrayList<>();

        for (int j = 0; j < k; j++) {
            list.add(wordArray[j].getWord());
        }

        return list;
    }

}
class Word  {

    private String word;
    private int frequency;

    public String getWord() { return word; }
    public int getFrequency() {return frequency;}

    public Word(String word, int frequency) {
        this.word = word;
        this.frequency = frequency;
    }

    @Override
    public String toString() {
        return "Word - " + word + " Frequency - " + frequency;
    }
}

class WordComparator implements Comparator<Word> {

    @Override
    public int compare(Word o1, Word o2) {

        int firstFrequency = o1.getFrequency();
        int secondFrequency = o2.getFrequency();

        if(firstFrequency == secondFrequency) {
            return o1.getWord().compareTo(o2.getWord());
        }

        return secondFrequency-firstFrequency;
    }
}
