Problem:
Score : 700 points

Problem Statement

We have a rooted binary tree with N vertices, where the vertices are numbered 1 to N.
Vertex 1 is the root, and the parent of Vertex i (i \geq 2) is Vertex \left[ \frac{i}{2} \right].

Each vertex has one item in it. The item in Vertex i has a value of V_i and a weight of W_i.
Now, process the following query Q times:

Given are a vertex v of the tree and a positive integer L.
Let us choose some (possibly none) of the items in v and the ancestors of v so that their total weight is at most L.
Find the maximum possible total value of the chosen items.

Here, Vertex u is said to be an ancestor of Vertex v when u is an indirect parent of v, that is, there exists a sequence of vertices w_1,w_2,\ldots,w_k (k\geq 2) where w_1=v, w_k=u, and w_{i+1} is the parent of w_i for each i.

Constraints

All values in input are integers.

1 \leq N < 2^{18}

1 \leq Q \leq 10^5

1 \leq V_i \leq 10^5

1 \leq W_i \leq 10^5

For the values v and L given in each query, 1 \leq v \leq N and 1 \leq L \leq 10^5.

Input

Let v_i and L_i be the values v and L given in the i-th query.
Then, Input is given from Standard Input in the following format:

N
V_1 W_1
:
V_N W_N
Q
v_1 L_1
:
v_Q L_Q

Output

For each integer i from 1 through Q,
the i-th line should contain the response to the i-th query.

Sample Input 1

3
1 2
2 3
3 4
3
1 1
2 5
3 5

Sample Output 1

0
3
3

In the first query, we are given only one choice: the item with (V, W)=(1,2). Since L = 1, we cannot actually choose it, so our response should be 0.

In the second query, we are given two choices: the items with (V, W)=(1,2) and (V, W)=(2,3). Since L = 5, we can choose both of them, so our response should be 3.

Sample Input 2

15
123 119
129 120
132 112
126 109
118 103
115 109
102 100
130 120
105 105
132 115
104 102
107 107
127 116
121 104
121 115
8
8 234
9 244
10 226
11 227
12 240
13 237
14 206
15 227

Sample Output 2

256
255
250
247
255
259
223
253

Solution in C++ (GCC 9.2.1) (judge verdict: Runtime Error)

//raja1999
 
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
 
#include <bits/stdc++.h>
#include <vector>
#include <set>
#include <map>
#include <string> 
#include <cstdio>
#include <cstdlib>
#include <climits>
#include <utility>
#include <algorithm>
#include <cmath>
#include <queue>
#include <stack>
#include <iomanip> 
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp> 
//setbase - cout << setbase (16)a; cout << 100 << endl; Prints 64
//setfill -   cout << setfill ('x') << setw (5); cout << 77 <<endl;prints xxx77
//setprecision - cout << setprecision (14) << f << endl; Prints x.xxxx
//cout.precision(x)  cout<<fixed<<val;  // prints x digits after decimal in val
 
using namespace std;
using namespace __gnu_pbds;
#define f(i,a,b) for(i=a;i<b;i++)
#define rep(i,n) f(i,0,n)
#define fd(i,a,b) for(i=a;i>=b;i--)
#define pb push_back
#define mp make_pair
#define vi vector< int >
#define vl vector< ll >
#define ss second
#define ff first
#define ll long long
#define pii pair< int,int >
#define pll pair< ll,ll >
#define sz(a) a.size()
#define inf (1000*1000*1000+5)
#define all(a) a.begin(),a.end()
#define tri pair<int,pii>
#define vii vector<pii>
#define vll vector<pll>
#define viii vector<tri>
#define mod (1000*1000*1000+7)
#define pqueue priority_queue< int >
#define pdqueue priority_queue< int,vi ,greater< int > >
//#define int ll
 
typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
 
 
//std::ios::sync_with_stdio(false);
ll v[(1<<18)+5],w[(1<<18)+5];
ll brute(int n,int l){
	ll val=0,lol,haha,j,k,res=0;
	vii vec;
	while(n>=1){
		vec.pb(mp(v[n],w[n]));
		n/=2;
		val++;
	}
	rep(j,(1<<val)){
		lol=0;
		haha=0;
		rep(k,vec.size()){
			if(j&(1<<k)){
				lol+=vec[k].ff;
				haha+=vec[k].ss;
			}
		}
		if(haha<=l){
			res=max(res,lol);
		}
	}	
	//cout<<res<<" "<<val<<endl;
	return res;
}
int u[100005],l[100005];
vector<pair<ll,ll> > :: iterator it;
vector<vll>GG((1<<9)+5);
vector<vl>MM((1<<9)+5);
int main(){
	std::ios::sync_with_stdio(false); cin.tie(NULL);
	ll n,q,i,val,c,lol,haha,res,j,k,maxi,req,pos,rem,iinf,node;
	iinf=inf;
	iinf*=inf;
	vii vec;
	cin>>n;
	rep(i,n){
		cin>>v[i+1]>>w[i+1];
	}
	cin>>q;
	rep(i,q){
		cin>>u[i]>>l[i];
	}
	if(n<128){
		rep(i,q){
			cout<<brute(u[i],l[i])<<endl;
		}
	}
	else{
		int lev=0;
		int n1=n;
		while(n1>1){
			n1/=2;
			lev++;
		}
		val=(lev+1)/2;
		f(i,1,n+1){
			n1=i;
			c=0;
			vec.clear();
			vec.pb(mp(v[i],w[i]));
			while(n1>1){
				c++;
				n1/=2;
				vec.pb(mp(v[n1],w[n1]));
			}
			if(c==val){
				rep(j,(1<<val)){
					lol=0;
					haha=0;
					rep(k,vec.size()){
						if(j&(1<<k)){
							lol+=vec[k].ff;
							haha+=vec[k].ss;
						}
					}
					if(haha<=100000){
						GG[i].pb(mp(haha,lol));
					}
				}
				sort(all(GG[i]));
				maxi=0;
				MM[i].resize(GG[i].size()+2);
				fd(j,GG[i].size()-1,0){
					maxi=max(maxi,GG[i][j].ss);
					MM[i][j]=maxi;
				}
			}
		}
		rep(i,q){
			n1=u[i];
			c=0;
			while(n1>1){
				c++;
				n1/=2;
			}
			if(c<val){
				cout<<brute(u[i],l[i])<<endl;
			}
			else{
				n1=u[i];
				req=c-val;
				vec.clear();
				while(req--){
					vec.pb(mp(v[n1],w[n1]));
					n1/=2;
				}
				node=n1;
				req=c-val;
				res=0;
				rep(j,(1<<req)){
					lol=0;
					haha=0;
					rep(k,vec.size()){
						if(j&(1<<k)){
							lol+=vec[k].ff;
							haha+=vec[k].ss;
						}
					}
					if(haha<=l[i]){
						rem=l[i]-haha;
						it=upper_bound(GG[node].begin(),GG[node].end(),mp(rem,iinf));
						it--;
						pos=(it-GG[node].begin());
						res=max(res,lol+MM[node][pos]);
					}
				}
				cout<<res<<endl;
			}
		}
	}
	return 0;
}