problem

AOR Ika and you came to the tournament-style table tennis tournament singles section for reconnaissance. For AOR Ika-chan, who wants to record all the games, you decide to ask for the number of games that will be played in this tournament.

There are $ N $ players in the tournament, each with a uniform number of $ 0, \ dots, N -1 $. Among them, $ M $ players abstained and did not participate in the match.

The number of games in this tournament will be determined based on the following rules.

* There are no seed players, and the number of wins required for any contestant to win is constant.
* If the opponent is absent, the match will not be played and the player who participated will win. It is not counted in the number of games.
* The tournament will end when the winner is decided.
* A person who loses a match will not play the match again. In other words, there will be no repechage or third place playoff.
* Since there is only one table tennis table, different games will not be played at the same time, and the winner will always be decided in each game (it will not be a draw).



The definition of the tournament is as follows. The tournament is represented by a full binary tree with a height of $ L = \ log_2 N $, and each apex of the leaf has the participant's uniform number written on it. Assuming that the root depth is 0, in the $ i $ round ($ 1 \ le i \ le L $), the players with the numbers written on the children of each vertex of the depth $ L --i $ will play a match. Write the winner's uniform number at the top.

<image>



output

Output the number of games played by the end of this tournament in one line. Also, output a line break at the end.

Example

Input

2 0


Output

1
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
  return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
  return a < b && (a = b, true);
}
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using ld = long double;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
  vll r(v.size());
  for (long long i = 0; i < (long long)(v.size()); i++) r[i] = v[i];
  return r;
}
inline void input(int &v) {
  v = 0;
  char c = 0;
  int p = 1;
  while (c < '0' || c > '9') {
    if (c == '-') p = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    v = (v << 3) + (v << 1) + c - '0';
    c = getchar();
  }
  v *= p;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
  o << "(" << v.first << ", " << v.second << ")";
  return o;
}
template <size_t...>
struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is>
struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
  using s = int[];
  (void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
    -> basic_ostream<Ch, Tr> & {
  os << "(";
  print_tuple(os, t, gen_seq<sizeof...(Args)>());
  return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
  for (long long i = 0; i < (long long)(v.size()); i++) {
    for (long long j = 0; j < (long long)(v[i].size()); j++)
      o << v[i][j] << " ";
    o << endl;
  }
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &v) {
  o << '[';
  for (long long i = 0; i < (long long)(v.size()); i++)
    o << v[i] << (i != v.size() - 1 ? ", " : "");
  o << "]";
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const deque<T> &v) {
  o << '[';
  for (long long i = 0; i < (long long)(v.size()); i++)
    o << v[i] << (i != v.size() - 1 ? ", " : "");
  o << "]";
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++)
    o << *it << (next(it) != m.end() ? ", " : "");
  o << "]";
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const unordered_set<T> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++)
    o << *it << (next(it) != m.end() ? ", " : "");
  o << "]";
  return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++)
    o << *it << (next(it) != m.end() ? ", " : "");
  o << "]";
  return o;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &o, const unordered_map<T, U, V> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++) o << *it;
  o << "]";
  return o;
}
vector<int> range(const int x, const int y) {
  vector<int> v(y - x + 1);
  iota(v.begin(), v.end(), x);
  return v;
}
template <typename T>
istream &operator>>(istream &i, vector<T> &o) {
  for (long long j = 0; j < (long long)(o.size()); j++) i >> o[j];
  return i;
}
template <typename T, typename S, typename U>
ostream &operator<<(ostream &o, const priority_queue<T, S, U> &v) {
  auto tmp = v;
  while (tmp.size()) {
    auto x = tmp.top();
    tmp.pop();
    o << x << " ";
  }
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const queue<T> &v) {
  auto tmp = v;
  while (tmp.size()) {
    auto x = tmp.front();
    tmp.pop();
    o << x << " ";
  }
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const stack<T> &v) {
  auto tmp = v;
  while (tmp.size()) {
    auto x = tmp.top();
    tmp.pop();
    o << x << " ";
  }
  return o;
}
template <typename T>
unordered_map<T, ll> counter(vector<T> vec) {
  unordered_map<T, ll> ret;
  for (auto &&x : vec) ret[x]++;
  return ret;
};
string substr(string s, P x) { return s.substr(x.first, x.second - x.first); }
void vizGraph(vvll &g, int mode = 0, string filename = "out.png") {
  ofstream ofs("./out.dot");
  ofs << "digraph graph_name {" << endl;
  set<P> memo;
  for (long long i = 0; i < (long long)(g.size()); i++)
    for (long long j = 0; j < (long long)(g[i].size()); j++) {
      if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i))))
        continue;
      memo.insert(P(i, g[i][j]));
      ofs << "    " << i << " -> " << g[i][j]
          << (mode ? " [arrowhead = none]" : "") << endl;
    }
  ofs << "}" << endl;
  ofs.close();
  system(((string) "dot -T png out.dot >" + filename).c_str());
}
size_t random_seed;
namespace std {
using argument_type = P;
template <>
struct hash<argument_type> {
  size_t operator()(argument_type const &x) const {
    size_t seed = random_seed;
    seed ^= hash<ll>{}(x.first);
    seed ^= (hash<ll>{}(x.second) << 1);
    return seed;
  }
};
};  // namespace std
struct timeval start;
double sec() {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return (tv.tv_sec - start.tv_sec) + (tv.tv_usec - start.tv_usec) * 1e-6;
}
struct init_ {
  init_() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    gettimeofday(&start, NULL);
    struct timeval myTime;
    struct tm *time_st;
    gettimeofday(&myTime, NULL);
    time_st = localtime(&myTime.tv_sec);
    srand(myTime.tv_usec);
    random_seed = RAND_MAX / 2 + rand() / 2;
  }
} init__;
int main(void) {
  ll n, m;
  cin >> n >> m;
  vll a(m);
  cin >> a;
  vll b(n, 1);
  for (long long i = 0; i < (long long)(m); i++) b[a[i]] = 0;
  ll ret = 0;
  while (b.size() > 1) {
    vll tmp;
    for (long long i = 0; i < (long long)(b.size() / 2); i++) {
      ret += b[2 * i + 1] && b[2 * i];
      tmp.push_back(b[2 * i + 1] || b[2 * i]);
    }
    swap(b, tmp);
  }
  cout << ret << endl;
  return 0;
}
