#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
using ll = long long;
using db = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
template <class T>
using V = vector<T>;
template <class T>
using PR = pair<T, T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
const int MX = 2e5 + 5;
const int MOD = 1e9 + 7;
const ll INF = 1e18;
const db PI = acos((db)-1);
const int xdir[4] = {1, 0, -1, 0}, ydir[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return x == 0 ? 0 : 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
template <class T>
bool ckmin(T& a, const T& b) {
  return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0;
}
template <class T, class U>
T fstTrue(T lo, T hi, U first) {
  hi++;
  assert(lo <= hi);
  while (lo < hi) {
    T mid = lo + (hi - lo) / 2;
    first(mid) ? hi = mid : lo = mid + 1;
  }
  return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U first) {
  lo--;
  assert(lo <= hi);
  while (lo < hi) {
    T mid = lo + (hi - lo + 1) / 2;
    first(mid) ? lo = mid : hi = mid - 1;
  }
  return lo;
}
template <class T>
void remDup(V<T>& v) {
  sort(begin(v), end(v));
  v.erase(unique(begin(v), end(v)), end(v));
}
template <typename T1, typename T2>
str to_string(pair<T1, T2> p);
template <typename T1, typename T2, typename T3>
str to_string(tuple<T1, T2, T3> p);
template <typename T1, typename T2, typename T3, typename T4>
str to_string(tuple<T1, T2, T3, T4> p);
str to_string(const str& S) { return '"' + S + '"'; }
str to_string(const char* S) { return to_string((str)S); }
str to_string(bool b) { return b ? "true" : "false"; }
template <class T>
str to_string(complex<T> c) {
  stringstream ss;
  ss << c;
  return ss.str();
}
template <size_t SZ>
str to_string(bitset<SZ> v) {
  str res = "";
  for (int i = (0); i < (SZ); ++i) res += char(v[i] + '0');
  return res;
}
template <typename T>
str to_string(T v) {
  bool fst = 1;
  str res = "";
  for (const auto& x : v) {
    if (!fst) res += " ";
    fst = 0;
    res += to_string(x);
  }
  return res;
}
template <typename T1, typename T2>
str to_string(pair<T1, T2> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void DBG() { cerr << endl; }
template <typename Head, typename... Tail>
void DBG(Head H, Tail... T) {
  cerr << " " << to_string(H);
  DBG(T...);
}
void setPrec() { cout << fixed << setprecision(15); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIn(str name) { freopen(name.c_str(), "r", stdin); }
void setOut(str name) { freopen(name.c_str(), "w", stdout); }
void setIO(str name = "") {
  unsyncIO();
  setPrec();
  if ((int)((name).size())) setIn(name + ".in"), setOut(name + ".out");
}
struct node {
  ll prefix, suffix, sum, msum;
  node() { prefix = suffix = sum = msum = 0LL; }
  node(ll value) {
    sum = value;
    prefix = suffix = sum = msum = max(0LL, value);
  }
};
node operator+(node a, node b) {
  node res;
  res.sum = a.sum + b.sum;
  res.prefix = max(a.prefix, a.sum + b.prefix);
  res.suffix = max(b.suffix, a.suffix + b.sum);
  res.msum = max({a.msum, b.msum, a.suffix + b.prefix});
  return res;
}
template <class T>
struct Seg {
  const T ID = T();
  T comb(T a, T b) { return a + b; }
  int N;
  vector<T> seg;
  void init(int _N) {
    N = _N;
    seg.assign(2 * N, ID);
  }
  void pull(int p) { seg[p] = comb(seg[2 * p], seg[2 * p + 1]); }
  void upd(int p, T val) {
    seg[p += N] = val;
    for (p /= 2; p; p /= 2) pull(p);
  }
  T query(int l, int r) {
    T ra = ID, rb = ID;
    for (l += N, r += N + 1; l < r; l /= 2, r /= 2) {
      if (l & 1) ra = comb(ra, seg[l++]);
      if (r & 1) rb = comb(seg[--r], rb);
    }
    return comb(ra, rb);
  }
};
Seg<node> ST;
int SZ(int n) {
  int sz = 0;
  while ((1 << sz) < n) sz++;
  return 1 << sz;
}
int32_t main() {
  setIO();
  int t;
  cin >> t;
  while (t--) {
    int n;
    cin >> n;
    vi arr(n);
    for (auto& x : arr) cin >> x, --x;
    vi p(n);
    for (int i = (0); i < (n); ++i) p[arr[i]] = i;
    ST.init(SZ(n));
    vb marked(n, false);
    bool res = true;
    int lst = n - 1, fst = 0;
    for (int i = (0); i < (n); ++i) {
      while (marked[lst]) --lst;
      ll csc = ST.query(fst, lst).msum + 1;
      auto can = [&](int x) { return ST.query(x, p[i]).sum == p[i] - x; };
      ll sum = p[i] - fstTrue(0, p[i], can) + 1;
      if (sum != csc) {
        res = false;
        break;
      }
      ST.upd(p[i], 1);
      marked[p[i]] = 1;
    }
    cout << (res ? "Yes\n" : "No\n");
  }
}
