Problem: Owl Sonya decided to become a partymaker. To train for this role she gather all her owl friends in the country house. There are m chairs located in a circle and consequently numbered with integers from 1 to m. Thus, chairs i and i + 1 are neighbouring for all i from 1 to m - 1. Chairs 1 and m are also neighbouring. Some chairs are occupied by her friends. There are n friends in total. No two friends occupy the same chair. Rules are the following:

  1. Each participant removes from the game the chair he is currently sitting on. 
  2. Each of the participants choose a direction that she will follow: clockwise (indices increase, from m goes to 1) and counter-clockwise (indices decrease, from 1 goes to m). This direction may coincide or be different for any pair of owls. 
  3. Each turn all guests move one step in the chosen directions. If some guest move to the position with a chair there, he removes this chair from the game. 
  4. Game ends if there are no more chairs left in the game. 



Owls are very busy and want to get rid of the game as soon as possible. They cooperate to pick the direction. Your goal is to find the minimum number o moves required to finish the game.

Input

The first line of the input contains a single integer m (1 ≤ m ≤ 109) — the length of the circle.

The second line contains a single integer n (1 ≤ n ≤ 100 000) — the number of friends.

Last line contains an increasing sequence of n integers ai (1 ≤ ai ≤ m) — initial positions of all owls.

Output

Print the minimum number of move required to finish the game. Note, that 0 also may be an answer.

Examples

Input

6
3
1 3 5


Output

1


Input

6
2
1 6


Output

2


Input

406
6
1 2 3 204 205 206


Output

100

Note

In the first sample, it's possible if all owls will move clockwise, i.e. in the direction of increasing indices.

In the sample, first owl has to move clockwise, while the second — counterclockwise.

In the third sample, the first and the fourth owls should move counterclockwise, while the third and the sixth — clockwise. The second and the firth may move in any direction.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000")
using namespace std;
void solve(bool);
void precalc();
clock_t start;
int testNumber = 1;
bool todo = true;
bool stress = false;
int main() {
  start = clock();
  int t = 1;
  cout.sync_with_stdio(0);
  cin.tie(0);
  precalc();
  cout.precision(10);
  cout << fixed;
  int testNum = 1;
  while (t--) {
    solve(true);
    ++testNumber;
  }
  return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
  if (!w) return 1 % mod;
  if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
  return binpow(q * 1LL * q % mod, w / 2, mod);
}
void precalc() {}
template <typename T>
T gcd(T q, T w) {
  while (w) {
    q %= w;
    swap(q, w);
  }
  return q;
}
template <typename T>
T lcm(T q, T w) {
  return q / gcd(q, w) * w;
}
void solve(bool read) {
  int m, n;
  cin >> m >> n;
  vector<int> a(n);
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
  }
  sort(a.begin(), a.end());
  for (int i = n - 1; i >= 0; --i) {
    a[i] -= a[0];
  }
  int L = -1, R = 1e9 + 2;
  while (L + 1 < R) {
    int k = (L + R) / 2;
    bool good = false;
    for (int w = 0; w < 2; ++w) {
      for (int start = 1; start <= 2 && start <= n; ++start) {
        if (start == 2 && a[1] - a[0] > 2 * k + 1) {
          continue;
        }
        bool f = true;
        int border = k;
        if (start == 2) {
          border = max(border, a[1]);
        }
        for (int i = start; i < n; ++i) {
          if (a[i] <= border + 1) {
            border = a[i] + k;
          } else {
            if (a[i] - border > k + 1) {
              f = false;
              break;
            } else {
              int j = i;
              int next_border = border;
              while (j < n && a[j] - border <= k + 1 &&
                     (j == i || a[j] > a[j - 1] + 1)) {
                if (j > i + 1) {
                  next_border = max(next_border, a[j - 2] + k);
                }
                ++j;
              }
              if (next_border + 1 >= a[j - 1]) {
                border = a[j - 1] + k;
              } else {
                border = a[j - 1];
                if (j > i + 1) {
                  border = max(border, a[j - 2] + k);
                }
              }
              i = j - 1;
            }
          }
        }
        if (f) {
          if (start == 1 && border >= m - 1) {
            good = true;
            break;
          }
          if (start == 2 && (border + k >= m + a[1] - 1 || border >= m - 1)) {
            good = true;
            break;
          }
        }
      }
      for (int i = 1; i < n; ++i) {
        a[i] = m - a[i];
      }
      sort(a.begin(), a.end());
    }
    if (good) {
      R = k;
    } else {
      L = k;
    }
  }
  cout << R << "\n";
}