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: Time Limit Exceeded)

#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;

// template {{{  0 
// using {{{ 1
using ll = long long int;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
// }}} 1
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x,y) scanf("%d%d", &x, &y)
#define Scd3(x,y,z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%lld", &x)
#define Scll2(x,y) scanf("%lld%lld", &x, &y)
#define Scll3(x,y,z) scanf("%lld%lld%lld", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (2e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Repe(x,y,z) for(ll x = z; x < y; x++)
#define Rep(x,y) Repe(x,y,0)
#define RRepe(x,y,z) for(ll x = y-z-1; x >= 0; x--)
#define RRep(x,y) RRepe(x,y,0)
// }}} 2
// output {{{ 2
#define YesNo(a) (a)?printf("Yes\n"):printf("No\n")
#define YESNO(a) (a)?printf("YES\n"):printf("NO\n")
// }}} 2
// }}} 1
// input {{{ 1
// }}} 1
// }}} 0

const int D = 11;

int main() {

    int N;
    Scd(N);

    vi v(1<<19),w(1<<19);
    Rep(i,N) {
        Scd2(v[i],w[i]);
        // v[i] = 1; w[i] = 1;
    }

    vector<map<int,int>> s(1<<19);

    deque<int> k;
    function<void(int,int)> dfs = [&]( int V, int d ){
        if( d == D ){
            int K = 1<<d;
            vii wv(1<<d);
            Rep(b,K){
                int vv = 0;
                int ww = 0;
                Rep(i,d){
                    if( (b>>i)&1 ){
                        vv += v[k[i]-1]; ww += w[k[i]-1];
                    }
                }
                wv[b] = {ww,-vv};
            }
            sort(wv.begin(),wv.end());
            int vm = -1;
            Rep(b,K){
                if( -wv[b].second > vm ){
                    vm = -wv[b].second;
                    s[V-(1<<D)][wv[b].first] = -wv[b].second;
                }
            }
            // printf ("!!%d\n", V-(1<<D));
        }else{
            k.push_back(V*2);
            dfs(V*2,d+1);
            k.pop_back();

            k.push_back(V*2+1);
            dfs(V*2+1,d+1);
            k.pop_back();
        }
    };


    k.push_back(1);
    dfs(1,0);
    k.pop_back();

    int Q;
    Scd(Q);

    Rep(qq,Q){
        int vv,L;
        Scd2(vv,L);
        map<int,int> t;
        k.clear();
        int ans = 0;
        if( vv >= (1<<D) ){
            int vvv = vv;
            while( vvv >= (1<<(D+1)) ) k.push_back(vvv), vvv/=2;
            k.push_back(vvv);
            int d = k.size();
            int K = 1<<d;
            vii wv(1<<d);
            Rep(b,K){
                int vv = 0;
                int ww = 0;
                Rep(i,d){
                    if( (b>>i)&1 ){
                        vv += v[k[i]-1]; ww += w[k[i]-1];
                    }
                }
                wv[b] = {ww,-vv};
            }
            sort(wv.begin(),wv.end());
            int vm = -1;
            Rep(b,K){
                if( -wv[b].second > vm ){
                    vm = -wv[b].second;
                    t[wv[b].first] = -wv[b].second;
                }
            }
            for( pii tt : t ){
                auto sv = --(s[vvv-(1<<D)].upper_bound(L-tt.first));
                if( tt.first > L ) continue;
                ans = max( ans, tt.second+sv->second);
            }
        }else{
            int vvv = vv;
            while( vvv ) k.push_back(vvv), vvv/=2;
            int d = k.size();
            int K = 1<<d;
            vii wv(1<<d);
            Rep(b,K){
                int vv = 0;
                int ww = 0;
                Rep(i,d){
                    if( (b>>i)&1 ){
                        vv += v[k[i]-1]; ww += w[k[i]-1];
                    }
                }
                if( ww <= L ) ans = max( ans, vv );
            }
        }
        printf ("%d\n", ans );
    }


    return 0;
}