Imp likes his plush toy a lot.

Recently, he found a machine that can clone plush toys. Imp knows that if he applies the machine to an original toy, he additionally gets one more original toy and one copy, and if he applies the machine to a copied toy, he gets two additional copies.

Initially, Imp has only one original toy. He wants to know if it is possible to use machine to get exactly *x* copied toys and *y* original toys? He can't throw toys away, and he can't apply the machine to a copy if he doesn't currently have any copies.
The only line contains two integers *x* and *y* (0 ≤ *x*, *y* ≤ 10<sup class="upper-index">9</sup>) — the number of copies and the number of original toys Imp wants to get (including the initial one).
In the first example, Imp has to apply the machine twice to original toys and then twice to copies.
6 3
Yes
4 2
No
1000 1001
Yes
1000000000 999999999
Yes
81452244 81452247
No
188032448 86524683
Yes
365289629 223844571
No
247579518 361164458
No
424836699 793451637
No
602093880 930771525
No
779351061 773124120
Yes
661640950 836815080
No
543930839 974134967
No
16155311 406422145
No
81601559 445618240
No
963891449 582938127
No
141148629 351661795
No
318405810 783948974
No
495662991 921268861
No
1 0
No
0 1
Yes
0 0
No
453462237 167520068
Yes
630719418 9872663
Yes
807976599 442159843
No
690266488 579479730
No
771581370 589752968
No
948838551 727072855
No
831128440 790763814
No
303352912 928083702
No
185642801 65403588
Yes
67932690 202723476
No
540157163 340043363
No
422447052 772330542
No
599704233 541054210
Yes
481994122 678374097
No
48564714 743566477
No
225821895 880886365
No
403079076 313173543
Yes
1000000000 1000000000
No
1 1
No
1 2
Yes
2 1
No
2 2
No
2 0
No
0 2
No
1000000000 1
No
777777 0
No
10 1
No
7 0
No
3 0
No
3 2
Yes
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<unordered_set>
#include<cmath>
#include<numeric>
#include<iterator>
#include<set>
#include<unordered_map>
#include<map>
#include<queue>
#include<cstring>
#include<stdio.h>
#include<fstream>
#include<iomanip>
#include<list>
#include<functional>
#include<bitset>
#include<chrono>
#include<climits>
#include<assert.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ordered_set tree<pair<ll,ll>, null_type,less<pair<ll,ll>>, rb_tree_tag,tree_order_statistics_node_update>

using namespace std;
using namespace __gnu_pbds;
using namespace std;


typedef                 long double lld;

#define ff              first
#define ss              second
#define ll              long long int
#define ull             unsigned long long int
#define pb              push_back
#define eb              emplace_back
#define mp              make_pair
#define pii             pair<int,int>
#define vi              vector<int>
#define mii             map<int,int>
#define pqb             priority_queue<int>
#define pqs             priority_queue<int,vi,greater<int> >
#define setbits(x)      __builtin_popcountll(x)
#define zrobits(x)      __builtin_ctzll(x)
#define mod             1000000007
#define modd            998244353
#define inf             1e18
#define nline           "\n"
#define ps(x,y)         fixed<<setprecision(y)<<x
#define mk(arr,n,type)  type *arr=new type[n];
#define w(x)            int x; cin>>x; while(x--)

#define fi(a,b,step)       for( ll i = a; i < b; i+=step)
#define fj(a,b,step)       for( ll j = a; j < b; j+=step)
#define fr(var,a,b,step)   for( ll var = a; var < b; var+=step)

#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x <<" "; _print(x); cerr << endl;
#else
#define debug(x)
#endif

void _print(ll t)     { cerr << t ; }
void _print(int t)    { cerr << t ; }
void _print(string t) { cerr << t ; }
void _print(char t)   { cerr << t ; }
void _print(lld t)    { cerr << t ; }
void _print(double t) { cerr << t ; }
void _print(ull t)    { cerr << t ; }

template <class T, class V> void _print(pair <T, V> p);
template <class T> void _print(vector <T> v);
template <class T> void _print(set <T> v);
template <class T, class V> void _print(map <T, V> v);
template <class T> void _print(multiset <T> v);
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.ff); cerr << ","; _print(p.ss); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}


ll inv(ll i) {if (i == 1) return 1; return (mod - ((mod / i) * inv(mod % i)) % mod) % mod;}

ll mod_mul(ll a, ll b) {a = a % mod; b = b % mod; return (((a * b) % mod) + mod) % mod;}

ll mod_add(ll a, ll b) {a = a % mod; b = b % mod; return (((a + b) % mod) + mod) % mod;}

ll gcd(ll a, ll b) { if (b == 0) return a; return gcd(b, a % b);}

ll ceil_div(ll a, ll b) {return a % b == 0 ? a / b : a / b + 1;}


//---------------------------------------------------------------------------


void IO() {
   ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
   freopen("input.txt", "r", stdin);
   freopen("output.txt", "w", stdout);
   freopen("error.txt", "w", stderr);
#endif
}




void solve() {




   int n, k; cin >> n >> k;

   if (n <= k) {
      if (k - n == 1)
         cout << "Yes";
      else cout << "No";
   } else {
      if ((n - k) & 1) {
         cout << "Yes";
      } else cout << "No";
   }
   cout << nline;














































   // int n;
   // cin >> n;
   // string s;
   // cin >> s;
   // int cnt = 0;
   // for (auto x : s)
   //    cnt += (x == '*' ? 1 : 0);
   // int pos = -1;
   // int cur = -1;
   // for (int i = 0; i < n; i++)
   // {
   //    if (s[i] == '*')
   //    {
   //       cur++;
   //       if (cur == cnt / 2)
   //          pos = i;
   //    }
   // }
   // long long ans = 0;
   // cur = pos - cnt / 2;
   // for (int i = 0; i < n; i++)
   //    if (s[i] == '*')
   //    {
   //       ans += abs(cur - i);
   //       cur++;
   //    }
   // cout << ans << endl;





// int n;
// cin >> n;
// vector<int> a(n), b(n);
// for (auto &it : a) cin >> it;
// for (auto &it : b) cin >> it;
// vector<int> c(n);
// for (int i = 0; i < n; ++i)c[i] = a[i] - b[i];
// sort(c.begin(), c.end());
// long long ans = 0;
// for (int i = 0; i < n; ++i) {
//    if (c[i] <= 0) continue;
//    int pos = lower_bound(c.begin(), c.end(), -c[i] + 1) - c.begin();
//    ans += i - pos;
// }
// cout << ans << endl;


// ull n, m; cin >> n >> m;
// // vector<ull>a(n, 0);

// map<ull, vector<ull>>look;
// vector<pair<ull, ull>>vp;
// for (ull i = 0; i < m; ++i)
// {
//    ull a, b; cin >> a >> b;
//    if (a > b)swap(a, b);
//    look[a].pb(b);
// }

// for (auto el : look) {
//    sort(begin(el.ss), end(el.ss));
// }
// debug(n);
// debug(m);
// set<ull>sett;
// ull ans = 0 , mxr = n  + 1;

// for (ull i = 1; i <= n; ++i) {

//    ull curr = i;
//    if (mxr == i) {
//       ull N = sett.size();
//       ans += (N * (N + 1)) / 2;
//       sett.clear();
//       sett.insert(curr);

//       if (look[curr].size()) {
//          debug("here");
//          auto pos = upper_bound(look[curr].begin(), look[curr].end(), *(sett.begin()));
//          debug(*pos);
//          // mxr = look[curr];
//          if (pos != look[curr].end())mxr =  *pos;
//          else mxr =  n + 1;
//       }
//       else mxr = n + 1;

//    } else {
//       sett.insert(curr);
//       auto pos = upper_bound(look[curr].begin(), look[curr].end(), *(sett.begin()));
//       ull val = n  + 1  ;
//       if (pos != look[curr].end())val = *pos, mxr = min(mxr, val);
//       else mxr = n + 1;

//    }
//    debug(i);
//    debug(ans);
//    debug(mxr);
//    debug(sett);
// }
// debug(sett);
// ull N = sett.size();
// ans += (N * (N + 1)) / 2;
// cout << ans << nline;

// ll n, k;
// cin >> n >> k;
// string s; cin >> s;
// string t; cin >> t;
// if (n >= 2 * k) {
//    sort(begin(s), end(s));
//    sort(begin(t), end(t));
//    if (s == t)cout << "YES";
//    else cout << "NO";
// } else if ( k <= (n + 1)) {
//    // cout << "NO"
//    if (k == n + 1) {
//       if (s == t)cout << "YES";
//       else cout << "NO";

//    } else {
//       if (s == t)cout << "YES";
//       else cout << "NO";
//    }
// }


}

int main() {

   IO();
   // cout << setprecision(13);
   ll t = 1;
   // cin >> t;
   debug(t);
   while (t--) {
      solve();
   }

   return 0;
}







/*
* stuff you should look before submission
* constraint and time limit
* int overflow
* special test case (n=0||n=1||n=2)
* don't get stuck on one approach if you get wrong answer
*/