#include <iostream>
#include <map>
#include <set>
#include <algorithm>
#include <vector>
#include <sstream>
#include <string>
#include <functional>
#include <queue>
#include <deque>
#include <stack>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <math.h>
#include <fstream>
#include <iterator>
#include <random>
#include <chrono>
 
 
#define forr(i,start,count) for (int i = (start); i < (start)+(count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) int i; cin >> i
#define readll(i) ll i; cin >> i
#define readdouble(i) double i; cin >> i
#define readstring(s) string s; cin >> s

typedef long long ll;
 
using namespace std;

template<class T>
T fastpower(T a, long long n) {  // n must be >= 1
  if (n % 2 == 0) {  
      T halfpower = fastpower<T>(a, n/2);
      return halfpower*halfpower;
  } else {
      if (n == 1) {  return a; } else {  
          T halfpower = fastpower<T>(a, n/2);
          return (halfpower*halfpower)*a;
      }
  }
};


int main()   {
    cout.precision(17);
    ll modd = 1000 * 1000 * 1000 + 7;
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    uniform_int_distribution<int> rand_gen(0, modd);   // rand_gen(rng) gets the rand no
    ll infinit = 10000000000000000;

//    auto start = chrono::steady_clock::now();

//    readint(test_cases);
    int test_cases = 1;
    int lmax = 100001;
    forr(t, 1, test_cases) {
        readll(n);
        vector<int> val;
        vector<int> wei;
        forr(i,0,n) {
            readint(vv); readint(ww);
            val.push_back(vv); wei.push_back(ww);
        }
        readint(q);
        vector<pair<ll,int>> qu;
        forr(i,0,q) {
            readll(vv); readint(lll);
            qu.push_back(make_pair(vv,lll));
            ll curr = vv;
        }

        vector<vector<ll>> memo(513, vector<ll>(lmax, 0));
        forr(w,0,lmax) {
            memo[1][w] = (w < wei[0] ? 0 : val[0]);
        }
        forr(v_,1,512) {
            if ((v_ > 1) && (v_ <= n)) {
                ll v_par = v_/2;
                forr(w,0,lmax) {
                    memo[v_][w] = (w < wei[v_-1] ? memo[v_par][w] : 
                       max(memo[v_par][w], memo[v_par][w-wei[v_-1]] + val[v_-1]));
                }
            }            
        }
        for (auto q : qu) {
            vector<ll> verts;
            ll curr = q.first;
            while (curr >512) {
                verts.push_back(curr); curr/=2;
            }
            if (verts.empty()) {
                cout << memo[curr][q.second] << endl;
            } else {
              ll w_max = q.second;
              ll max_val = 0;
              int ppp = fastpower<ll>(2,verts.size());
              forr(i,0,ppp) {
                int kk = i;
                ll total_w = 0, total_val = 0, i_=0;
                while (kk>0) {
                    if (kk%2==1) {
                        total_w += wei[verts[i_]-1]; total_val += val[verts[i_]-1];
                    }
                    kk/=2; i_++;
                }
                if (w_max >= total_w) {
                   max_val = max(max_val, total_val+memo[curr][w_max-total_w]);
                }
              }
              cout << max_val << endl;
            }
        }

    }

//    auto end = chrono::steady_clock::now();
//    cout << chrono::duration_cast<chrono::milliseconds>(end - start).count() << endl;

    return 0;
}

Measured memory_bytes: 408412