Andrew's favourite Krakozyabra has recenly fled away and now he's eager to bring it back!

At the moment the refugee is inside an icy cave with n icicles dangling from the ceiling located in integer coordinates numbered from 1 to n. The distance between floor and the i-th icicle is equal to ai.

Andrew is free to choose an arbitrary integer point T in range from 1 to n inclusive and at time instant 0 launch a sound wave spreading into both sides (left and right) at the speed of one point per second. Any icicle touched by the wave starts falling at the same speed (that means that in a second the distance from floor to icicle decreases by one but cannot become less that zero). While distance from icicle to floor is more than zero, it is considered passable; as soon as it becomes zero, the icicle blocks the path and prohibits passing.

Krakozyabra is initially (i.e. at time instant 0) is located at point <image> and starts running in the right direction at the speed of one point per second. You can assume that events in a single second happen in the following order: first Krakozyabra changes its position, and only then the sound spreads and icicles fall; in particular, that means that if Krakozyabra is currently at point <image> and the falling (i.e. already touched by the sound wave) icicle at point i is 1 point from the floor, then Krakozyabra will pass it and find itself at <image> and only after that the icicle will finally fall and block the path.

Krakozyabra is considered entrapped if there are fallen (i.e. with ai = 0) icicles both to the left and to the right of its current position. Help Andrew find the minimum possible time it takes to entrap Krakozyabra by choosing the optimal value of T or report that this mission is impossible.

Input

The first line contains the number of icicles n (2 ≤ n ≤ 105).

The next line contains n space-separated numbers ai (1 ≤ ai ≤ 105) — the distances from floor to icicles.

Output

Print an only integer — the minimum time it takes to entrap Krakozyabra between two fallen icicles. If it is impossible, print  - 1.

Examples

Input

5
1 4 3 5 1


Output

3


Input

4
1 2 1 1


Output

2


Input

2
2 1


Output

3


Input

2
1 2


Output

-1

Note

In sample case one it's optimal to launch the sound wave from point 3. Then in two seconds icicles 1 and 5 will start falling, and in one more seconds they will block the paths. Krakozyabra will be located at <image> at that time. Note that icicle number 3 will also be fallen, so there will actually be two icicles blocking the path to the left.

In sample case two it is optimal to launch the wave from point 2 and entrap Krakozyabra in 2 seconds.

In sample case four the answer is impossible.
#include <bits/stdc++.h>
using namespace std;
const int infinito = 1000000000;
void minimiza(int &a, int b) { a = min(a, b); }
const int tope = 1 << 19;
const int primero = 1 << 18;
void reset(int minimo[tope]) {
  for (int i = tope - 1; i >= 0; i--) minimo[i] = infinito;
}
void insertar(int minimo[tope], int pos, int val) {
  pos += primero;
  minimo[pos] = val;
  while (pos > 1) {
    pos /= 2;
    minimo[pos] = min(minimo[2 * pos], minimo[2 * pos + 1]);
  }
}
void borrar(int minimo[tope], int pos) { insertar(minimo, pos, infinito); }
int minimoantes(int minimo[tope], int pos) {
  pos += primero;
  int mini = minimo[pos];
  while (pos > 1) {
    if (pos % 2 == 1) minimiza(mini, minimo[pos - 1]);
    pos /= 2;
  }
  return mini;
}
void borrar(multiset<int> &s, int x) {
  multiset<int>::iterator it = s.find(x);
  s.erase(x);
}
void insertar(multiset<int> &s, int x) { s.insert(x); }
int getmin(multiset<int> &s) {
  if (int(s.size()) == 0) return infinito;
  return *(s.begin());
}
const int limite = 1000000;
int n;
int a[limite];
vector<int> limitele[limite], limiteri[limite];
multiset<int> inside[2], outside[2];
set<int> posinside;
int minimo[2][tope];
int main() {
  ios::sync_with_stdio(false);
  for (int i = 0; i < 2; i++) reset(minimo[i]);
  cin >> n;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
    insertar(minimo[0], i, i + a[i]);
    if (a[i] < i) {
      limitele[a[i] + 1].push_back(i);
      limiteri[i + (i - a[i])].push_back(i);
    }
  }
  int sol = infinito;
  for (int ind = 1; ind <= n; ind++) {
    {
      vector<int> v = limitele[ind];
      for (int iv = 0; iv < int(v.size()); iv++) {
        int i = v[iv];
        borrar(minimo[0], i);
        insertar(inside[0], i + a[i]);
        posinside.insert(i);
      }
    }
    {
      int i = ind;
      if (a[i] < i) {
        borrar(inside[0], i + a[i]);
        insertar(inside[1], -i + a[i]);
      } else {
        borrar(minimo[0], i);
        insertar(minimo[1], i, -i + a[i]);
      }
    }
    {
      vector<int> v = limiteri[ind];
      for (int iv = 0; iv < int(v.size()); iv++) {
        int i = v[iv];
        borrar(inside[1], -i + a[i]);
        posinside.erase(i);
        insertar(minimo[1], i, -i + a[i]);
        posinside.erase(i);
      }
    }
    if (int(posinside.size()) > 0) {
      int pos = *(posinside.begin());
      minimiza(sol, max(min(minimoantes(minimo[0], pos) - ind,
                            minimoantes(minimo[1], pos) + ind),
                        min(getmin(inside[0]) - ind, getmin(inside[1]) + ind)));
    }
  }
  if (infinito / 2 < sol)
    cout << -1 << endl;
  else
    cout << sol << endl;
}
