This is the harder version of the problem. In this version, 1≤n,m≤2⋅105. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems.

You are given a sequence of integers a=[a1,a2,…,an] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:

[11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
[40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1≤k≤n) is given, then the subsequence is called optimal if:

it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b1,b2,…,bk] is lexicographically smaller than the sequence c=[c1,c2,…,ck] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1≤t≤k) such that b1=c1, b2=c2, …, bt−1=ct−1 and at the same time bt<ct. For example:

[10,20,20] lexicographically less than [10,21,1],
[7,99,99] is lexicographically less than [10,21,1],
[10,21,0] is lexicographically less than [10,21,1].
You are given a sequence of a=[a1,a2,…,an] and m requests, each consisting of two numbers kj and posj (1≤k≤n, 1≤posj≤kj). For each query, print the value that is in the index posj of the optimal subsequence of the given sequence a for k=kj.

For example, if n=4, a=[10,20,30,20], kj=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request kj=2, posj=1 is the number 20, and the answer to the request kj=2, posj=2 is the number 30.

Input
The first line contains an integer n (1≤n≤2⋅105) — the length of the sequence a.

The second line contains elements of the sequence a: integer numbers a1,a2,…,an (1≤ai≤109).

The third line contains an integer m (1≤m≤2⋅105) — the number of requests.

The following m lines contain pairs of integers kj and posj (1≤k≤n, 1≤posj≤kj) — the requests.

Output
Print m integers r1,r2,…,rm (1≤rj≤109) one per line: answers to the requests in the order they appear in the input. The value of rj should be equal to the value contained in the position posj of the optimal subsequence for k=kj.

Examples
inputCopy
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
outputCopy
20
10
20
10
20
10
inputCopy
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
outputCopy
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:

for k=1: [20],
for k=2: [10,20],
for k=3: [10,20,10].

easy version直接暴力即可。

对于hard：我们可以想：我们肯定是找最大的值，然后再找第二大的值，依次加入，直到等于我们的查询个数。

所以相当于是我们对输入的数组从大到小排序之后，依次查找。但是这道题要求了字典序，所以我们如果数字大小一样，则按照下标排序。

我们同时对查询排序，k从小到大排序，然后离线去做。每次二分，找到数量大于等于pos的最小的位置，然后输出即可，所以我们将下标插入到树状数组中即可。

具体实现可以看代码，代码是比较简单的。

AC代码：

#pragma GCC optimize(2)
#include<bits/stdc++.h>
//#define int long long
#define lowbit(x) (x&(-x))
using namespace std;
const int N=2e5+10;
int n,m,d[N],res[N],b[N];
struct node{int k,pos,id;}q[N];
struct nums{int a,id;}t[N];
int cmp1(nums c,nums d){return c.a==d.a?c.id<d.id:c.a>d.a;}
int cmp2(node a,node b){return a.k<b.k;}
inline void add(int x,int v){for(;x<=n;x+=lowbit(x)) d[x]+=v;}
inline int ask(int x){int s=0; for(;x;x-=lowbit(x)) s+=d[x]; return s;}
signed main(){
	cin>>n;
	for(int i=1;i<=n;i++)	scanf("%d",&t[i].a),t[i].id=i,b[i]=t[i].a;
	cin>>m;
	for(int i=1;i<=m;i++)	scanf("%d %d",&q[i].k,&q[i].pos),q[i].id=i;
	sort(t+1,t+1+n,cmp1); sort(q+1,q+1+m,cmp2); int j=1;
	for(int i=1;i<=m;i++){
		for(;j<=q[i].k;j++)	add(t[j].id,1);
		int l=1,r=n;
		while(l<r){
			int mid=l+r>>1;
			if(ask(mid)>=q[i].pos)	r=mid;
			else	l=mid+1;	
		}
		res[q[i].id]=b[l];
	}
	for(int i=1;i<=m;i++)	printf("%d\n",res[i]);
	return 0;
}