func_code_string: #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 );     }   }   