#include <bits/stdc++.h>
using namespace std;
int in() {
  int a;
  scanf("%d", &a);
  return a;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int INF = 1000000;
class SegTree {
 private:
  vector<long long> *tree;
  int n;

 public:
  SegTree(int _n) {
    tree = new vector<long long>(4 * _n + 1);
    n = _n;
    tree->at(0) = INF;
  }
  ~SegTree() { delete tree; }
  void build_sum(vector<int> &buf) {
    b(buf.begin(), buf.end() - 1, tree->begin() + 1);
  }
  void b(vector<int>::iterator begin, vector<int>::iterator end,
         vector<long long>::iterator ver) {
    if (begin == end) {
      *ver = *end;
    } else {
      vector<int>::iterator mid;
      vector<long long>::iterator son1, son2;
      mid = begin + distance(begin, end) / 2;
      son1 = ver + distance(tree->begin(), ver);
      son2 = son1 + 1;
      b(begin, mid, son1);
      b(mid + 1, end, son2);
      *ver = *son1 + *son2;
    }
  }
  long long sum(int l, int r) {
    return sum(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
               tree->begin() + l, tree->begin() + r);
  }
  long long sum(vector<long long>::iterator begin,
                vector<long long>::iterator end,
                vector<long long>::iterator ver, vector<long long>::iterator l,
                vector<long long>::iterator r) {
    if (l > r) {
      return 0;
    }
    if (l == begin && r == end) {
      return *ver;
    }
    vector<long long>::iterator mid;
    mid = begin + distance(begin, end) / 2;
    return sum(begin, mid, ver + distance(tree->begin(), ver), l,
               (r > mid) ? (mid) : (r)) +
           sum(mid + 1, end, ver + distance(tree->begin(), ver) + 1,
               (l > mid + 1) ? (l) : (mid + 1), r);
  }
  void update_sum(int pos, int val) {
    update_sum(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
               tree->begin() + pos, val);
  }
  void update_sum(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator pos, int val) {
    if (end == begin) {
      *ver = val;
    } else {
      vector<long long>::iterator mid;
      mid = begin + distance(begin, end) / 2;
      if (pos <= mid) {
        update_sum(begin, mid, ver + distance(tree->begin(), ver), pos, val);
      } else {
        update_sum(mid + 1, end, ver + distance(tree->begin(), ver) + 1, pos,
                   val);
      }
      *ver = *(ver + distance(tree->begin(), ver)) +
             *(ver + distance(tree->begin(), ver) + 1);
    }
  }
  void build_max(vector<int> &buf) {
    ma(buf.begin(), buf.end() - 1, tree->begin() + 1);
  }
  void ma(vector<int>::iterator begin, vector<int>::iterator end,
          vector<long long>::iterator ver) {
    if (begin == end) {
      *ver = *end;
    } else {
      vector<int>::iterator mid;
      vector<long long>::iterator son1, son2;
      mid = begin + distance(begin, end) / 2;
      son1 = ver + distance(tree->begin(), ver);
      son2 = son1 + 1;
      ma(begin, mid, son1);
      ma(mid + 1, end, son2);
      *ver = max(*son1, *son2);
    }
  }
  long long max_t(int l, int r) {
    return max_t(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
                 tree->begin() + l, tree->begin() + r);
  }
  long long max_t(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator l,
                  vector<long long>::iterator r) {
    if (l > r) {
      return 0;
    }
    if (l == begin && r == end) {
      return *ver;
    }
    vector<long long>::iterator mid;
    mid = begin + distance(begin, end) / 2;
    return max(max_t(begin, mid, ver + distance(tree->begin(), ver), l,
                     (r > mid) ? (mid) : (r)),
               max_t(mid + 1, end, ver + distance(tree->begin(), ver) + 1,
                     (l > mid + 1) ? (l) : (mid + 1), r));
  }
  void update_max(int pos, int val) {
    update_max(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
               tree->begin() + pos, val);
  }
  void update_max(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator pos, int val) {
    if (end == begin) {
      *ver = val;
    } else {
      vector<long long>::iterator mid;
      mid = begin + distance(begin, end) / 2;
      if (pos <= mid) {
        update_max(begin, mid, ver + distance(tree->begin(), ver), pos, val);
      } else {
        update_max(mid + 1, end, ver + distance(tree->begin(), ver) + 1, pos,
                   val);
      }
      *ver = max(*(ver + distance(tree->begin(), ver)),
                 *(ver + distance(tree->begin(), ver) + 1));
    }
  }
  void build_min(vector<int> &buf) {
    tree->assign(4 * n + 1, INF);
    mi(buf.begin(), buf.end() - 1, tree->begin() + 1);
  }
  void mi(vector<int>::iterator begin, vector<int>::iterator end,
          vector<long long>::iterator ver) {
    if (begin == end) {
      *ver = *end;
    } else {
      vector<int>::iterator mid;
      vector<long long>::iterator son1, son2;
      mid = begin + distance(begin, end) / 2;
      son1 = ver + distance(tree->begin(), ver);
      son2 = son1 + 1;
      mi(begin, mid, son1);
      mi(mid + 1, end, son2);
      *ver = min(*son1, *son2);
    }
  }
  long long min_t(int l, int r) {
    return min_t(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
                 tree->begin() + l, tree->begin() + r);
  }
  long long min_t(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator l,
                  vector<long long>::iterator r) {
    if (l > r) {
      return INF;
    }
    if (l == begin && r == end) {
      return *ver;
    }
    vector<long long>::iterator mid;
    mid = begin + distance(begin, end) / 2;
    return min(min_t(begin, mid, ver + distance(tree->begin(), ver), l,
                     (r > mid) ? (mid) : (r)),
               min_t(mid + 1, end, ver + distance(tree->begin(), ver) + 1,
                     (l > mid + 1) ? (l) : (mid + 1), r));
  }
  void update_min(int pos, int val) {
    update_min(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
               tree->begin() + pos, val);
  }
  void update_min(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator pos, int val) {
    if (end == begin) {
      *ver = val;
    } else {
      vector<long long>::iterator mid;
      mid = begin + distance(begin, end) / 2;
      if (pos <= mid) {
        update_min(begin, mid, ver + distance(tree->begin(), ver), pos, val);
      } else {
        update_min(mid + 1, end, ver + distance(tree->begin(), ver) + 1, pos,
                   val);
      }
      *ver = min(*(ver + distance(tree->begin(), ver)),
                 *(ver + distance(tree->begin(), ver) + 1));
    }
  }
  void build_gcd(vector<int> &buf) {
    gc(buf.begin(), buf.end() - 1, tree->begin() + 1);
  }
  void gc(vector<int>::iterator begin, vector<int>::iterator end,
          vector<long long>::iterator ver) {
    if (begin == end) {
      *ver = *end;
    } else {
      vector<int>::iterator mid;
      vector<long long>::iterator son1, son2;
      mid = begin + distance(begin, end) / 2;
      son1 = ver + distance(tree->begin(), ver);
      son2 = son1 + 1;
      gc(begin, mid, son1);
      gc(mid + 1, end, son2);
      *ver = gcd(*son1, *son2);
    }
  }
  long long gcd_t(int l, int r) {
    return gcd_t(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
                 tree->begin() + l, tree->begin() + r);
  }
  long long gcd_t(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator l,
                  vector<long long>::iterator r) {
    if (l > r) {
      return 0;
    }
    if (l == begin && r == end) {
      return *ver;
    }
    vector<long long>::iterator mid;
    mid = begin + distance(begin, end) / 2;
    return gcd(gcd_t(begin, mid, ver + distance(tree->begin(), ver), l,
                     (r > mid) ? (mid) : (r)),
               gcd_t(mid + 1, end, ver + distance(tree->begin(), ver) + 1,
                     (l > mid + 1) ? (l) : (mid + 1), r));
  }
  void update_gcd(int pos, int val) {
    update_gcd(tree->begin() + 1, tree->begin() + n, tree->begin() + 1,
               tree->begin() + pos, val);
  }
  void update_gcd(vector<long long>::iterator begin,
                  vector<long long>::iterator end,
                  vector<long long>::iterator ver,
                  vector<long long>::iterator pos, int val) {
    if (end == begin) {
      *ver = val;
    } else {
      vector<long long>::iterator mid;
      mid = begin + distance(begin, end) / 2;
      if (pos <= mid) {
        update_gcd(begin, mid, ver + distance(tree->begin(), ver), pos, val);
      } else {
        update_gcd(mid + 1, end, ver + distance(tree->begin(), ver) + 1, pos,
                   val);
      }
      *ver = gcd(*(ver + distance(tree->begin(), ver)),
                 *(ver + distance(tree->begin(), ver) + 1));
    }
  }
};
void func(int a) { cout << a; }
void tt2(void f(int q)) { f(11); }
long long fac(int n) {
  if (n == 1) return 1;
  return n * fac(n - 1);
}
class tree {
 public:
  tree(int n, int d, tree *p) {
    a = n;
    deep = d;
    parent = p;
  }
  tree(int n, int d) {
    a = n;
    deep = d;
  }
  int a, deep;
  bool l, r;
  tree *left, *right, *parent;
};
template <typename my_type>
class FindTree {
 private:
  tree *root;
  int count;
  int max_deep;
  set<int> q;
  void insert(my_type a, tree &pos) {
    if (a == pos.a) {
      --count;
      return;
    }
    if (a < pos.a) {
      if (pos.l) {
        insert(a, *pos.left);
      } else {
        max_deep = max(max_deep, pos.deep + 1);
        pos.left = new tree(a, pos.deep + 1, &pos);
        pos.l = 1;
        return;
      }
    } else {
      if (pos.r) {
        insert(a, *pos.right);
      } else {
        max_deep = max(max_deep, pos.deep + 1);
        pos.r = 1;
        pos.right = new tree(a, pos.deep + 1, &pos);
        return;
      }
    }
  }
  int getmax(tree pos) {
    if (pos.r) {
      getmax(*pos.right);
    } else {
      if (pos.l) return (*(pos.left)).a;
      return (*(pos.parent)).a;
    }
  }
  void tra(tree &pos) {
    if (pos.l ^ pos.r) {
      q.insert(pos.a);
    }
    if (pos.l) tra(*pos.left);
    if (pos.r) tra(*pos.right);
  }

 public:
  FindTree() {
    count = 0;
    max_deep = 0;
  }
  void Insert(my_type n) {
    if (count == 0) {
      ++count;
      root = new tree(n, 1);
      root->l = 0;
      root->r = 0;
      return;
    }
    ++count;
    insert(n, *root);
  }
  int size() { return count; }
  int get_deep() { return max_deep; }
  int get2max() { return getmax(*root); }
  void treverse() {
    tra(*root);
    for (set<int>::iterator i = q.begin(); i != q.end(); ++i) cout << *i << " ";
  }
};
int main() {
  int n = in(), x = in(), y = in();
  if (n % 2 == 1) {
    cout << "NO";
    return 0;
  }
  n /= 2;
  if ((x == n && y == n) || (x == n && y == n + 1) || (x == n + 1 && y == n) ||
      (x == n + 1 && y == n + 1)) {
    cout << "NO";
    return 0;
  }
  cout << "YES";
  return 0;
}
