#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")

#include <bits/stdc++.h>
using namespace std;

#define nl "\n"
const int mod = 998244353; 
const int maxn = 3e5 + 15;

int n, a[maxn], pmin[maxn], pmax[maxn], smin[maxn], smax[maxn];
bool nxt[maxn];

void solve()
{
    cin >> n;
    for(int i = 1; i <= n; ++i) cin >> a[i];
    
    pmin[0] = mod; pmax[0] = -mod; 
    smin[n+1] = mod; smax[n+1] = -mod;
    
    for(int i = 1; i <= n; ++i) {
        pmin[i] = min(pmin[i-1], a[i]);
        pmax[i] = max(pmax[i-1], a[i]);
    }
    for(int i = n; i >= 1; --i) {
        smin[i] = min(smin[i+1], a[i]);
        smax[i] = max(smax[i+1], a[i]);
    }
    
    vector<int> q; 
    q.reserve(n + 1);
    q.push_back(1);
    
    vector<int> nq;
    nq.reserve(n + 1);
    
    int ans = 0;
    
    for(int k = 1; k <= n; ++k)
    {
        nq.clear();
        for(int l : q)
        {
            int r = n - k + l - 1;
            int low = mod, high = -mod;
            
            if(l > 1) { 
                low = pmin[l-1]; 
                high = pmax[l-1]; 
            }
            if(r < n) { 
                if(smin[r+1] < low) low = smin[r+1];
                if(smax[r+1] > high) high = smax[r+1];
            }
            
            bool go_L = false, go_R = false;
            
            if(l < r) {
                int type_L = 0, type_R = 0;
                
                if(a[l] < low) type_L = 1;
                else if(a[l] > high) type_L = 2;
                
                if(a[r] < low) type_R = 1;
                else if(a[r] > high) type_R = 2;
                
                if(type_L == 1 && type_R == 1) {
                    if(a[l] > a[r]) go_L = true;
                    else if(a[l] < a[r]) go_R = true;
                    else { go_L = true; go_R = true; }
                } 
                else if(type_L == 2 && type_R == 2) {
                    if(a[l] < a[r]) go_L = true;
                    else if(a[l] > a[r]) go_R = true;
                    else { go_L = true; go_R = true; }
                } 
                else {
                    if(type_L != 0) go_L = true;
                    if(type_R != 0) go_R = true;
                }
            } 
            else if(l == r) {
                if(a[l] < low || a[l] > high) go_L = true;
            }
            
            if(go_L && !nxt[l+1]) { 
                nxt[l+1] = 1; 
                nq.push_back(l+1); 
            }
            if(go_R && !nxt[l]) { 
                nxt[l] = 1; 
                nq.push_back(l); 
            }
        }
        
        if(nq.empty()) break;
        ans = k;
        q.swap(nq);
        for(int l : q) nxt[l] = 0; 
    }
    cout << ans << nl;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    
    int tt; 
    if(cin >> tt) {
        while(tt--) solve();
    }
    return 0;
}