Problem: You're given an array a_1, …, a_n of n non-negative integers.

Let's call it sharpened if and only if there exists an integer 1 ≤ k ≤ n such that a_1 < a_2 < … < a_k and a_k > a_{k+1} > … > a_n. In particular, any strictly increasing or strictly decreasing array is sharpened. For example:

  * The arrays [4], [0, 1], [12, 10, 8] and [3, 11, 15, 9, 7, 4] are sharpened; 
  * The arrays [2, 8, 2, 8, 6, 5], [0, 1, 1, 0] and [2, 5, 6, 9, 8, 8] are not sharpened. 



You can do the following operation as many times as you want: choose any strictly positive element of the array, and decrease it by one. Formally, you can choose any i (1 ≤ i ≤ n) such that a_i>0 and assign a_i := a_i - 1.

Tell if it's possible to make the given array sharpened using some number (possibly zero) of these operations.

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 15\ 000) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer n (1 ≤ n ≤ 3 ⋅ 10^5).

The second line of each test case contains a sequence of n non-negative integers a_1, …, a_n (0 ≤ a_i ≤ 10^9).

It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.

Output

For each test case, output a single line containing "Yes" (without quotes) if it's possible to make the given array sharpened using the described operations, or "No" (without quotes) otherwise.

Example

Input


10
1
248618
3
12 10 8
6
100 11 15 9 7 8
4
0 1 1 0
2
0 0
2
0 1
2
1 0
2
1 1
3
0 1 0
3
1 0 1


Output


Yes
Yes
Yes
No
No
Yes
Yes
Yes
Yes
No

Note

In the first and the second test case of the first test, the given array is already sharpened.

In the third test case of the first test, we can transform the array into [3, 11, 15, 9, 7, 4] (decrease the first element 97 times and decrease the last element 4 times). It is sharpened because 3 < 11 < 15 and 15 > 9 > 7 > 4.

In the fourth test case of the first test, it's impossible to make the given array sharpened.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using vl = vector<ll>;
using pll = pair<ll, ll>;
ll mod = 1000000007;
mt19937_64 rng(0xDEADBEEF);
string alpha = []() {
  string ans;
  for (char c = 'a'; c <= 'z'; c++) ans.push_back(c);
  return ans;
}();
template <typename T1>
istream& operator>>(istream& c, vector<T1>& v) {
  for (auto& i1 : v) c >> i1;
  return c;
}
template <typename T1, typename T2>
istream& operator>>(istream& c, pair<T1, T2>& p) {
  c >> p.first >> p.second;
  return c;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& c, pair<T1, T2> p) {
  return c << p.first << ' ' << p.second;
}
template <typename T1>
ostream& operator<<(ostream& c, const vector<T1>& v) {
  for (auto& i1 : v) c << i1 << ' ';
  return c;
}
template <typename T1>
ostream& operator<<(ostream& c, const set<T1>& v) {
  for (auto& i1 : v) c << i1 << ' ';
  return c;
}
template <typename T1>
void print(const vector<T1>& v) {
  for (auto& i1 : v) cout << i1 << endl;
}
class TIn {};
const TIn vIn;
template <typename T1>
struct TInContainer {
  T1 Value;
};
template <typename T1>
TInContainer<T1> operator>>(const T1& value, const TIn vIn) {
  return {value};
}
template <typename T1>
bool operator>>(const TInContainer<T1>& e, const set<T1>& v) {
  return v.find(e.Value) != v.end();
}
template <typename T1>
bool operator>>(const TInContainer<T1>& e, const vector<T1>& v) {
  return find(v.begin(), v.end(), e.Value) != v.end();
}
template <typename T1>
bool operator>>(const TInContainer<T1>& e, const multiset<T1>& v) {
  return v.find(e.Value) != v.end();
}
template <typename T1, typename T2>
bool operator>>(const TInContainer<T1>& e, const map<T1, T2>& v) {
  return v.find(e.Value) != v.end();
}
template <typename T1, typename T2>
bool operator>>(const TInContainer<T1>& e, const multimap<T1, T2>& v) {
  return v.find(e.Value) != v.end();
}
template <typename T1>
bool operator>>(const TInContainer<T1>& e, const pair<T1, T1>& v) {
  return !(e.Value < v.first || v.second < e.Value);
}
template <typename T1>
ll operator+(const vector<T1>& v) {
  return v.size();
}
template <typename T1>
ll operator+(const set<T1>& v) {
  return v.size();
}
template <typename T1>
ll operator+(const multiset<T1>& v) {
  return v.size();
}
template <typename T1, typename T2>
ll operator+(const map<T1, T2>& v) {
  return v.size();
}
template <typename T1, typename T2>
ll operator+(const multimap<T1, T2>& v) {
  return v.size();
}
template <typename T1>
ll operator+(const queue<T1>& v) {
  return v.size();
}
template <typename T1>
ll operator+(const priority_queue<T1>& v) {
  return v.size();
}
ll operator+(const string& v) { return v.size(); }
template <typename T1, typename T2>
void operator+=(set<T1>& c, const T2& v) {
  c.insert(v);
}
template <typename T1, typename T2>
void operator+=(multiset<T1>& c, const T2& v) {
  c.insert(v);
}
template <typename T1, typename T2, typename T3>
void operator+=(multimap<T1, T2>& c, const T3& v) {
  c.insert(v);
}
template <typename T1, typename T2>
void operator+=(vector<T1>& c, const T2& v) {
  c.push_back(v);
}
template <typename T1, typename T2>
void operator+=(queue<T1>& c, const T2& v) {
  c.push(v);
}
template <typename T1, typename T2>
void operator+=(priority_queue<T1>& c, const T2& v) {
  c.push(v);
}
template <typename T1, typename T2>
void operator-=(set<T1>& c, const T2& v) {
  c.erase(v);
}
template <typename T1, typename T2>
void operator-=(multiset<T1>& c, const T2& v) {
  c.erase(c.find(v));
}
template <typename T1, typename T2, typename T3>
void operator-=(map<T1, T2>& c, const T3& v) {
  c.erase(v);
}
template <typename T1, typename T2, typename T3>
void operator-=(multimap<T1, T2>& c, const T3& v) {
  c.erase(c.find(v));
}
template <typename T1>
T1 operator--(set<T1>& c) {
  T1 ans = *c.begin();
  c.erase(c.begin());
  return ans;
}
template <typename T1>
T1 operator--(multiset<T1>& c) {
  T1 ans = *c.begin();
  c.erase(c.begin());
  return ans;
}
template <typename T1>
T1 operator--(vector<T1>& c) {
  T1 ans = c.back();
  c.pop_back();
  return ans;
}
char operator--(string& c) {
  char ans = c.back();
  c.pop_back();
  return ans;
}
template <typename T1>
T1 operator--(queue<T1>& c) {
  T1 ans = c.front();
  c.pop();
  return ans;
}
template <typename T1>
T1 operator--(priority_queue<T1>& c) {
  T1 ans = c.top();
  c.pop();
  return ans;
}
template <typename T1, typename T2>
ll operator/(const T1& v, T2& c) {
  return count(c.begin(), c.end(), v);
}
template <typename T1, typename T2>
void operator^=(set<T1>& c, const T2& v) {
  if (c.find(v) != c.end())
    c.erase(v);
  else
    c.insert(v);
}
template <typename T1>
void operator<<=(map<T1, ll>& m, const vector<T1>& v) {
  for (auto& i1 : v) m[i1]++;
}
void operator<<=(map<char, ll>& m, const string& v) {
  for (auto& i1 : v) m[i1]++;
}
template <typename T1, typename T2>
void operator<<=(map<T1, T2>& m, const vector<pair<T1, T2>>& v) {
  for (auto& i1 : v) m[i1.first] = i1.second;
}
template <typename T1>
void operator<<=(set<T1>& s, const vector<T1>& v) {
  for (auto& i1 : v) s.insert(i1);
}
template <typename T1>
void operator<<=(multiset<T1>& s, const vector<T1>& v) {
  for (auto& i1 : v) s.insert(i1);
}
void operator<<=(set<char>& s, const string& v) {
  for (auto& i1 : v) s.insert(i1);
}
template <typename T1>
T1 sum(const vector<T1>& v) {
  return accumulate(v.begin(), v.end(), T1{});
}
template <typename T1>
T1 max(const vector<T1>& v) {
  return *max_element(v.begin(), v.end());
}
template <typename T1>
T1 min(const vector<T1>& v) {
  return *min_element(v.begin(), v.end());
}
template <typename T1>
void sort(vector<T1>& v) {
  sort(v.begin(), v.end());
}
template <typename T1>
void reverse(vector<T1>& v) {
  reverse(v.begin(), v.end());
}
void reverse(string& a) { reverse(a.begin(), a.end()); }
void sort(string& a) { sort(a.begin(), a.end()); }
template <typename T1>
vector<T1> sorted(vector<T1> v) {
  sort(v.begin(), v.end());
  return move(v);
}
template <typename T1>
vector<T1> reversed(vector<T1> v) {
  reverse(v.begin(), v.end());
  return move(v);
}
string reversed(string a) {
  reverse(a.begin(), a.end());
  return move(a);
}
string sorted(string a) {
  sort(a.begin(), a.end());
  return move(a);
}
template <typename T1>
T1 max(const pair<T1, T1>& v) {
  return max(v.first, v.second);
}
template <typename T1>
T1 min(const pair<T1, T1>& v) {
  return min(v.first, v.second);
}
template <typename T1>
void sort(pair<T1, T1>& v) {
  if (v.second < v.first) swap(v.first, v.second);
}
template <typename T1>
pair<T1, T1> sorted(pair<T1, T1> v) {
  if (v.second < v.first) swap(v.first, v.second);
  return move(v);
}
template <typename T1, typename T2>
vector<pair<T2, T1>> swapped(const map<T1, T2>& mp) {
  vector<pair<T2, T1>> ans;
  for (auto& i1 : mp) ans.push_back({i1.second, i1.first});
  return move(ans);
}
namespace geom {
pll operator+(pll a, pll b) { return {a.first + b.first, a.second + b.second}; }
pll operator-(pll a, pll b) { return {a.first - b.first, a.second - b.second}; }
pll operator-(pll a) { return {-a.first, -a.second}; }
pll operator*(pll a) { return {-a.second, a.first}; }
pll operator~(pll a) { return {a.second, a.first}; }
pll operator++(pll& a) {
  pll ans = a;
  a.first++;
  a.second++;
  return ans;
}
pll operator--(pll& a) {
  pll ans = a;
  a.first--;
  a.second--;
  return ans;
}
ll operator*(pll a, pll b) { return a.first * b.first + a.second * b.second; }
ll operator+(pll a) { return a.first * a.first + a.second * a.second; }
ll abs(pll a) { return std::abs(a.first) + std::abs(a.second); }
pll sum(const vector<pll>& v) {
  using namespace geom;
  pll ans{};
  for (auto e : v) ans = ans + e;
  return ans;
}
void operator+=(pll& a, pll b) { a = a + b; }
void operator-=(pll& a, pll b) { a = a - b; }
pll operator*(ll a, pll p) { return {p.first * a, p.second * a}; }
void operator*=(pll p, ll a) {
  p.first *= a;
  p.second *= a;
}
}  // namespace geom
using vpll = vector<pll>;
using mll = map<ll, ll>;
using vvl = vector<vl>;
using vs = vector<string>;
using md = double;
template <typename T1>
class asc_queue : public priority_queue<T1, vector<T1>, greater<T1>> {};
template <typename T1>
class desc_queue : public priority_queue<T1> {};
template <typename T1>
string tostring(T1 a) {
  stringstream ss;
  ss << a;
  return ss.str();
}
namespace algo {
template <typename T1>
T1 binpow_mod(T1 a, ll b, ll c = mod) {
  if (b == 1) return a;
  if (b & 1) return binpow_mod(a, b - 1, c) * a % c;
  T1 res = binpow_mod(a, b >> 1, c);
  return res * res % c;
}
template <typename T1>
T1 binpow(T1 a, ll b) {
  if (b == 1) return a;
  if (b & 1) return binpow(a, b - 1) * a;
  T1 res = binpow(a, b >> 1);
  return res * res;
}
class dsu {
  vl v;
  ll Sz;

 public:
  dsu(ll sz) : v(sz), Sz(sz) {
    for (ll i = 0, iend = ll(sz); i < iend; i++) v[i] = i;
  }
  ll get(ll i) {
    if (i == v[i]) return v[i];
    return v[i] = get(v[i]);
  }
  ll operator[](ll i) { return get(i); }
  void join(ll a, ll b) {
    if (get(a) == get(b)) return;
    Sz--;
    if (rng() % 2) swap(a, b);
    v[get(a)] = get(b);
  }
  ll size() const { return Sz; }
};
ll gcd(ll a, ll b) {
  while (a) tie(a, b) = pll{b % a, a};
  return b;
}
ll gcdv(vl& v) { return accumulate(v.begin(), v.end(), v.front(), gcd); }
union mask_t {
  uint64_t i;
  bitset<64> b;
  mask_t(ll q) { i = q; }
  mask_t(bitset<64> q) { b = q; }
};
vector<bool> eratosphen(ll mx) {
  if (mx == 0) return {1};
  vector<bool> ans(mx + 1);
  ans[0] = 1;
  ans[1] = 1;
  for (ll i = 2; i <= mx; i++) {
    if (ans[i]) continue;
    for (ll j = i + i; j <= mx; j += i) ans[j] = 1;
  }
  return ans;
}
vl primes(ll n) {
  auto v = eratosphen(n);
  vl ans;
  for (ll i = 0, iend = ll(v.size()); i < iend; i++)
    if (!v[i]) ans += i;
  return ans;
}
template <typename T1>
vector<T1> prefixsum(vector<T1> v) {
  vector<T1> ans(1);
  for (auto& i1 : v) ans += ans.back() + i1;
  return move(ans);
}
template <typename T1>
vector<T1> suffixsum(vector<T1> v) {
  return reversed(prefixsum(reversed(v)));
}
template <typename T1>
T1 merge(const T1& a, const T1& b) {
  T1 ans(a.size() + b.size());
  merge(a.begin(), a.end(), b.begin(), b.end(), ans.begin());
  return move(ans);
}
pll exgcd(pll a) {
  if (a.first == 0) {
    if (a.second == 1)
      return {0, 1};
    else
      return {0, 0};
  }
  pll val = exgcd({a.second % a.first, a.first});
  return {val.second - (a.second / a.first) * val.first, val.first};
}
template <typename T1>
vl kmp(T1& v) {
  vl ans(+v);
  ll j = 0;
  for (ll i = 0, iend = ll(+v); i < iend; i++) {
    while (j != 0 && v[i] != v[j]) j = ans[j - 1];
    if (v[j] == v[i] && j < i) j++;
    ans[i] = j;
  }
  return ans;
}
}  // namespace algo
int main() {
  cin.sync_with_stdio(0);
  cin.tie(0);
  cout.sync_with_stdio(0);
  cout.tie(0);
  using namespace geom;
  ll q;
  cin >> q;
  for (ll j = 0, jend = ll(q); j < jend; j++) {
    ll n;
    cin >> n;
    vl v(n);
    cin >> v;
    vl can_be_left, can_be_right;
    for (ll i = 0, iend = ll(n); i < iend; i++) {
      can_be_left += v[i] >= i;
      can_be_right += v[i] >= n - 1 - i;
    }
    for (ll i = 0, iend = ll(n - 1); i < iend; i++) {
      can_be_left[i + 1] *= can_be_left[i];
      can_be_right[n - 1 - i - 1] *= can_be_right[n - 1 - i];
    }
    ll ok = 0;
    for (ll i = 0, iend = ll(n); i < iend; i++) {
      if (can_be_left[i] && can_be_right[i]) {
        ok = 1;
      }
    }
    cout << (ok ? "Yes" : "No") << endl;
  }
  return 0;
}