#include<bits/stdc++.h>
 
using namespace std;
 
#define int long long
 
void solve(){
	int x;
	cin >> x;
	int ans = 0;
	int a1 = 0, a2 = 0, a3 = 0;
	while(min({a1, a2, a3}) < x){
		if (a1 <= a2 && a1 <= a3){
			a1 = min(a2, a3) * 2 + 1;
		}
		else if (a2 <= a1 && a2 <= a3){
			a2 = min(a1, a3) * 2 + 1;
		}
		else{
			a3 = min(a1, a2) * 2 + 1;
		}
		ans++;
	}
	cout << ans << '\n';
}
 
signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
 
	int tests = 1;
	cin >> tests;
	for (int test = 0; test < tests; test++){
		solve();
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
 
#define int long long
 
void solve(){
	int n, m;
	cin >> n >> m;
	vector<vector<int>> a(m);
 
	for (int i = 0; i < m; i++){
		for (int j = 0; j < 3; j++){
			int x;
			cin >> x;
			a[i].emplace_back(x);
		}
		sort(a[i].begin(), a[i].end());
	}

	vector<int> fib(n + 5);
	fib[0] = 1;
	fib[1] = 2;
	for (int i = 2; i < n + 1; i++){
		fib[i] = fib[i - 1] + fib[i - 2];
	}
 
	for (int i = 0; i < m; i++){
		if (a[i][0] >= fib[n - 1] && a[i][1] >= fib[n - 1] && a[i][2] >= fib[n]){
			cout << '1';
		}
		else{
			cout << '0';
		}
	}
	cout << '\n';
}
 
signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
 
	int tests = 1;
	cin >> tests;
	for (int test = 0; test < tests; test++){
        solve();
	}
	return 0;
}

for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    i = 0
    ans = 10**18
    while i < n:
        j = i
        while j < n and a[j] == a[i]:
            j += 1
        ans = min(ans, (i + n - j) * a[i])
        i = j
    print(ans)

#include<bits/stdc++.h>
 
using namespace std;
 
void solve(){
	int n, m;
	cin >> n >> m;
	vector<int> a(m);
	for (int i = 0; i < m; i++){
		cin >> a[i];
	}
	sort(a.begin(), a.end());
	vector<vector<int>> ans(n, vector<int> (6));
 
	for (int i = 0; i < n; i += 2){
		if (i + 1 == n){
			for (int j = 0; j < 6; j++){
				if (j % 2 == 0){
					ans[i][j] = a[i / 2];
				}
				else{
					ans[i][j] = a[m - i / 2 - 1];
				}
			}
		}
		else{
			for (int j = 0; j < 6; j++){
				if (j % 2 == 0){
					ans[i][j] = a[i / 2];
					ans[i + 1][j] = a[m - i / 2 - 1];
				}
				else{
					ans[i][j] = a[m - i / 2 - 1];
					ans[i + 1][j] = a[i / 2];
				}
			}
		}
	}
 
	for (int i = 0; i < n; i++){
		for (int j = 0; j < 6; j++){
			cout << ans[i][j] << ' ';
		}
		cout << '\n';
	}
}
 
signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
 
	int tests = 1;
	cin >> tests;
	for (int test = 0; test < tests; test++){
		solve();
	}
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
 
#define int long long
 
void solve(){
	int n, q;
	cin >> n >> q;
	string s;
	cin >> s;
	vector<vector<set<int>>> st(3, vector<set<int>> (3));
	for (int i = 0; i < q; i++){
		char x, y;
		cin >> x >> y;
		st[x - 'a'][y - 'a'].insert(i);
	}

	for (int i = 0; i < n; i++){
		if (s[i] == 'a'){
			continue;
		}
		
		if (s[i] == 'b'){
			if (!st[1][0].empty()){
				st[1][0].erase(st[1][0].begin());
				s[i] = 'a';
				continue;
			}
			if (!st[1][2].empty()){
				auto ind = *st[1][2].begin();
				auto lb = st[2][0].lower_bound(ind);
				if (lb != st[2][0].end()){
					st[1][2].erase(ind);
					st[2][0].erase(lb);
					s[i] = 'a';
					continue;
				}
			}
		}

		if (s[i] == 'c'){
			if (!st[2][0].empty()){
				st[2][0].erase(st[2][0].begin());
				s[i] = 'a';
				continue;
			}
			if (!st[2][1].empty()){
				auto ind = *st[2][1].begin();
				st[2][1].erase(ind);
				s[i] = 'b';
				auto lb = st[1][0].lower_bound(ind);
				if (lb != st[1][0].end()){
					st[1][0].erase(lb);
					s[i] = 'a';
				}
			}
		}
	}

	cout << s << '\n';
}
 
signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
 
	int tests = 1;
	cin >> tests;
	for (int test = 0; test < tests; test++){
                solve();
	}
	return 0;
}

#include<bits/stdc++.h>
 
using namespace std;
 
void solve(){
	int p, s;
	cin >> p >> s;
	int g = gcd(p, s);
	p /= g;
	s /= g;
 
	if (p > 4 * s){
		cout << -1 << '\n';
		return;
	}
 
	if (p > 2 * s){
		int a = 4 * s - p;
		int b = p - 2 * s;
		if (a % b != 0){
			cout << -1 << '\n';
			return;
		}
		int x = a / b + 1;
 
		cout << x << '\n';
		for (int i = 0; i < x; i++){
			cout << i << ' ' << 0 << '\n';
		}
		return;
	}
 
	if (p == 2 * s){
		cout << 4 << '\n';
		cout << 0 << ' ' << 0 << '\n';
		cout << 0 << ' ' << 1 << '\n';
		cout << 1 << ' ' << 1 << '\n';
		cout << 1 << ' ' << 0 << '\n';
		return;
	}
 
	if (p % 2 == 1){
		if (p == 1){
			int s2 = 4 * s;
 
			cout << s2 * s2 << '\n';
			for (int i = 0; i < s2; i++){
				for (int j = 0; j < s2; j++){
					cout << i << ' ' << j << '\n';
				}
			}
			return;
		}
		int x = (p - 1) / 2;
		int s2 = 4 * (s - x);
 
		cout << s2 * (x * 4 + s2) << '\n';
		for (int i = 0; i < s2 + s2 * x * 4; i++){
			cout << i << ' ' << 0 << '\n';
		}
		for (int i = 0; i < s2 - 1; i++){
			for (int j = 0; j < s2; j++){
				cout << j << ' ' << i + 1 << '\n';
			}
		}
	}
	else{
		if (p == 2){
			int s2 = 4 * (s - 1);
 
			cout << s2 * (4 + s2) << '\n';
			for (int i = 0; i < s2 + 2 * s2; i++){
				cout << i << ' ' << 0 << '\n';
			}
			for (int i = 0; i < s2 + 2 * s2; i++){
				cout << i << ' ' << 1 << '\n';
			}
			for (int i = 0; i < s2 - 2; i++){
				for (int j = 0; j < s2; j++){
					cout << j << ' ' << i + 2 << '\n';
				}
			}
			return;
		}
		int x = (p - 2) / 2;
		int s2 = 4 * (s - x - 1);
 
		cout << s2 + 2 * s2 + 4 * x * s2 + s2 + 2 * s2 + (s2 - 2) * s2 << '\n';
		for (int i = 0; i < s2 + 2 * s2 + 4 * x * s2; i++){
			cout << i << ' ' << 0 << '\n';
		}
		for (int i = 0; i < s2 + 2 * s2; i++){
			cout << i << ' ' << 1 << '\n';
		}
		for (int i = 0; i < s2 - 2; i++){
			for (int j = 0; j < s2; j++){
				cout << j << ' ' << i + 2 << '\n';
			}
		}
	}
}
 
signed main()
{
#ifdef FELIX
	auto _clock_start = chrono::high_resolution_clock::now();
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
 
	int tests = 1;
	cin >> tests;
	for (int test = 0; test < tests; test++){
		solve();
	}
#ifdef FELIX
	cerr << "Executed in " << chrono::duration_cast<chrono::milliseconds>(
		chrono::high_resolution_clock::now()
			- _clock_start).count() << "ms." << endl;
#endif
	return 0;
}

#include<bits/stdc++.h>
 
using namespace std;
 
struct PersistentSegmentTree{
	#define _null -1
	struct Node{
		int l, r;
		int val;
		Node(): l(-1), r(-1), val(_null) {}
	};
	vector<Node> data;
	vector<int> roots;
	PersistentSegmentTree(){}
 
	inline void copy(int x, int y){
		data[x].l = data[y].l;
		data[x].r = data[y].r;
		data[x].val = data[y].val;
	}
 
	int build(int v, int l, int r, vector<int>& a){
		if (data.size() == v){
			data.emplace_back();
		}
		if (l == r){
			data[v].val = a[l];
			return v;
		}
		int m = (l + r) / 2;
		data[v].l = build(data.size(), l, m, a);
		data[v].r = build(data.size(), m + 1, r, a);
		data[v].val = max(data[data[v].l].val, data[data[v].r].val);
		return v;
	}
 
	int update(int v, int l, int r, int pos, int val){
		int new_v = data.size();
		data.emplace_back();
		copy(new_v, v);
		if (l == r){
			data[new_v].val = val;
			return new_v;
		}
		int m = (l + r) / 2;
		if (pos <= m){
			data[new_v].l = update(data[v].l, l, m, pos, val);
		}
		else{
			data[new_v].r = update(data[v].r, m + 1, r, pos, val);
		}
		data[new_v].val = max(data[data[new_v].l].val, data[data[new_v].r].val);
		return new_v;
	}
 
	int get(int v, int l, int r, int ql, int qr){
		if (ql > qr){
			return _null;
		}
		if (l == ql && r == qr){
			return data[v].val;
		}
		int m = (l + r) / 2;
		return max(get(data[v].l, l, m, ql, min(qr, m)), 
			get(data[v].r, m + 1, r, max(ql, m + 1), qr));
	}
};
 
void solve(){
	int n;
	cin >> n;
 
	vector<int> p(n);
	for(int i = 0; i < n; i++){
		cin >> p[i];
		p[i]--;
	}
 
	vector<pair<int,int>> p2(n);
	for (int i = 0; i < n; i++){
		p2[i] = {p[i], i};
	}
	sort(p2.begin(), p2.end());
 
	vector<tuple<int,int,int,int>> seg;
	set<pair<int,int>> st;
 
	st.insert({-2, -2});
	st.insert({n + 1, n + 1});
 
	for (int i = 0; i < n; i++){
		auto [val, ind] = p2[i];
		auto up = st.lower_bound(pair{ind, -1});
		auto down = (--st.lower_bound(pair{ind, -1}));
 
		int l, r;
 
		if (down->second == ind - 1 && up->first == ind + 1){
			l = down->first, r = up->second;
			st.erase(up);
			st.erase(down);
		}
		else if (down->second == ind - 1){
			l = down->first, r = down->second + 1;
			st.erase(down);
		}
		else if (up->first == ind + 1){
			l = up->first - 1, r = up->second;
			st.erase(up);
		}
		else{
			l = ind, r = ind;
		}
		st.insert({l, r});
 
		up = st.lower_bound(pair{l + 1, -1});
		down = (--st.lower_bound(pair{l, -1}));
 
		if (l > 0){
			seg.emplace_back(max(0, down->second + 1), l - 1, r, i * 2);
		}
		if (r < n - 1){
			seg.emplace_back(l, r, min(n - 1, up->first - 1), i * 2 + 1);
		}
	}
 
	sort(seg.begin(), seg.end());
 
	vector<tuple<int,int,int>> seg2;
	for (int i = 0; i < seg.size(); i++){
		auto [l1, r1, r2, ind] = seg[i];
		seg2.emplace_back(r1 + 1, r2, ind);
	}
	sort(seg2.begin(), seg2.end());
 
	vector<int> pos(2 * n, -1);
	for (int i = 0; i < seg2.size(); i++){
		auto [l, r, ind] = seg2[i];
		pos[ind] = i;
	}
 
	set<pair<int,int>> open_left_segs;
 
	vector<int> cur(2 * n, -1);
	PersistentSegmentTree tree;
	tree.roots.emplace_back(tree.build(0, 0, 2 * n - 1, cur));
 
	vector<int> T(n, -1);
	int u = 0;
	for (int i = 0; i < n; i++){
		while(u < seg.size() && get<0>(seg[u]) <= i){
			auto [l1, r1, r2, ind] = seg[u];
			open_left_segs.insert({r1, pos[ind]});
			tree.roots.emplace_back(tree.update(tree.roots.back(), 0, 2 * n - 1, pos[ind], r2));
			u++;
		}
		while(!open_left_segs.empty() && open_left_segs.begin()->first < i){
			auto [r, ind] = *open_left_segs.begin();
			open_left_segs.erase(open_left_segs.begin());
			tree.roots.emplace_back(tree.update(tree.roots.back(), 0, 2 * n - 1, ind, -1));
		}
		T[i] = tree.roots.back();
	}
 
	int q;
	cin >> q;
	for (int i = 0; i < q; i++){
		if (i % 10 == 0){
			cout.flush();
		}
		int l, r;
		cin >> l >> r;
		l--;
		r--;
		auto lb = lower_bound(seg2.begin(), seg2.end(), tuple{l + 1, -1, -1});
		if (lb == seg2.end()){
			cout << "NO\n";
			continue;
		}
		auto lb2 = lower_bound(seg2.begin(), seg2.end(), tuple{r + 1, -1, -1});
 
		int val;
		if (lb2 == seg2.end()){
			val = tree.get(T[l], 0, 2 * n - 1, pos[get<2>(*lb)], 2 * n - 1);
		}
		else{
			val = tree.get(T[l], 0, 2 * n - 1, pos[get<2>(*lb)], pos[get<2>(*lb2)] - 1);
		}
		cout << (val >= r ? "YES\n" : "NO\n");
	}
	cout.flush();
}
 
signed main()
{
#ifdef FELIX
	auto _clock_start = chrono::high_resolution_clock::now();
#endif
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
 
	int tests = 1;
	//cin >> tests;
	for (int test = 0; test < tests; test++){
		solve();
	}
#ifdef FELIX
	cerr << "Executed in " << chrono::duration_cast<chrono::milliseconds>(
		chrono::high_resolution_clock::now()
			- _clock_start).count() << "ms." << endl;
#endif
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define forn(i, n) for (int i = 0; i < int(n); ++i)

const int INF = 1e9;
const int LOGN = 18;

struct solver{
    int n;
    vector<int> p;

    solver(const vector<int> &p) : p(p){
        n = p.size();
        build();
    }

    vector<int> nxtmn, nxtmx;

    vector<vector<int>> up;
    vector<vector<int>> mx;

    void build(){
        nxtmx.resize(n);
        vector<int> stmn, stmx;
        for (int i = n - 1; i >= 0; --i){
            while (!stmx.empty() && p[stmx.back()] < p[i])
                stmx.pop_back();
            nxtmx[i] = (stmx.empty() ? n : stmx.back());
            stmx.push_back(i);
        }
        vector<vector<int>> qr(n + 1);
        forn(i, n) qr[nxtmx[i]].push_back(i);
        nxtmn.assign(n, n);
        for (int i = n - 1; i >= 0; --i){
            while (!stmn.empty() && p[stmn.back()] > p[i])
                stmn.pop_back();
            stmn.push_back(i);
            for (int j : qr[i]){
                int l = 0, r = int(stmn.size()) - 1;
                while (l <= r){
                    int m = (l + r) / 2;
                    if (p[stmn[m]] < p[j]){
                        nxtmn[j] = stmn[m];
                        l = m + 1;
                    }
                    else{
                        r = m - 1;
                    }
                }
            }
        }
        up.assign(n + 1, vector<int>(LOGN));
        mx.assign(n + 1, vector<int>(LOGN));
        forn(i, n){
            up[i][0] = nxtmx[i];
            mx[i][0] = nxtmn[i];
        }
        up[n][0] = n;
        mx[n][0] = 0;
        for (int j = 1; j < LOGN; ++j) forn(i, n + 1){
            up[i][j] = up[up[i][j - 1]][j - 1];
            mx[i][j] = max(mx[i][j - 1], mx[up[i][j - 1]][j - 1]);
        }
    }

    bool query(int l, int r){
        int v = l;
        for (int i = LOGN - 1; i >= 0; --i){
            if (up[v][i] >= r) continue;
            if (mx[v][i] >= r) return true;
            v = up[v][i];
        }
        return false;
    }
};

int main(){
#ifdef _DEBUG
    freopen("input.txt", "r", stdin);
#endif
    cin.tie(0);
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    vector<vector<int>> p(2, vector<int>(n));
    forn(i, n){
        cin >> p[0][i];
        --p[0][i];
    }
    p[1] = p[0];
    reverse(p[1].begin(), p[1].end());
    solver p0(p[0]);
    solver p1(p[1]);
    int m;
    cin >> m;
    forn(i, m){
		if (i % 10 == 0){
			cout.flush();
		}
        int l, r;
        cin >> l >> r;
        --l; -- r;
        bool ans = p0.query(l, r + 1) || p1.query(n - r - 1, n - l);
        cout << (ans ? "YES\n" : "NO\n");
    }
    cout.flush();
}