#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
//  #define int long long

#define all(X) (X).begin(), (X).end()
#define reset(X) memset(X, 0, sizeof(X))
#define mp(a, b) make_pair(a, b)
#define pb push_back
#define endl '\n'
#define fi first
#define se second


using namespace __gnu_pbds;
using namespace std;
const int mod=1e9+7;
 // const int mod=998244353;
 // const int mod=1e9+9;
const int INF=4e18+10;
// const int INF=4e18+10;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define read(n) int n; cin>>n;
#define readv(x, n) vector<int> x(n); for(auto &i:x) cin>>i;


typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef pair<int, int> pii;

template<typename T1,typename T2>
void set_min(T1& a, T2 b)
{
    a=min(a, (T1)b);
}


int multiply(int a, int b, int in_mod){return (a*b)%in_mod;}
int mult_identity(int a){return 1;}


auto power(auto a, int b, int in_mod)
{
    auto prod=mult_identity(a);
    auto mult=a%in_mod;
    while(b!=0)
    {
        if(b%2)
        {
            prod=multiply(prod,mult, in_mod);

        }
        mult=multiply(mult, mult,in_mod);
        b/=2;
    }
    return prod;
}
int mod_inv(int q, int in_mod)
{

    return power(q, in_mod-2,in_mod);
}
const int MAXN=(1<<18)+10;
const int fake_maxn= 1e5+10;
vector<int> v(MAXN);
vector<int> w(MAXN);
vector<int> ans(MAXN);
struct value
{
    int w, v, index;
};
vector<value> q_real[MAXN];
int n;


vector<vector<int>> dp(11,vector<int> (MAXN,0));

void dfs(int node, int depth)
{

    if(depth==11)
        return;

    for(int i=0;i<fake_maxn;i++)
    {
        dp[depth][i] = dp[depth-1][i];
        if(i>=w[node])
        {
            dp[depth][i]=max(dp[depth][i], dp[depth-1][i-w[node]]+v[node]);
        }
    }


    if(depth <= 10)
    {
        //solve the queries;
        for(auto q:q_real[node])
        {
            int w=q.w;
            int v= q.v;
            int index = q.index;
            ans[index] = max(ans[index], dp[depth][w] + v);
        }
    }
    if(2*node<=n)
        dfs(2*node, depth+1);
    if(2*node+1<=n)
        dfs(2*node+1,depth+1);
}

void solve()
{
    cin>>n;

    for(int i=1;i<=n;i++)
    {
        cin>>v[i]>>w[i];
    }

    int q;
    cin>>q;
    for(int i=0;i<q;i++)
    {
        int v, l;
        cin>>v>>l;
        q_real[v].pb({l, 0, i});
    }


    //starting from bottom most nodes push queries to their parent
    for(int i=n;i>=(1<<10);i--)
    {
        for(auto q:q_real[i])
        {
            int w= q.w;
            int v= q.v;
            int index = q.index;

            q_real[i/2].pb({w, v, index});
            if(w>=::w[i])
            q_real[i/2].pb({w-::w[i], v+::v[i], index});
        }
    }
    //solve queires for 1e9 by brute


    dfs(1, 1);



    for(auto q:q_real[0])
    {
        ans[q.index] = max(ans[q.index], q.v);
    }
    for(int i=0;i<q;i++)
        cout<<ans[i]<<" ";


}

signed main()

{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
#ifndef ONLINE_JUDGE
    if (fopen("INPUT.txt", "r"))
    {
        freopen("INPUT.txt", "r", stdin);
        freopen("OUTPUT.txt", "w", stdout);
    }
#endif
    auto clk = clock();
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    // -------------------------------------Code starts here---------------------------------------------------------------------

    int t = 1;
    // cin>>t;
    for (int test = 1; test <= t; test++)
    {
        // cout<<"Case #"<<test<<": ";
        // cout<<endl;
        solve();
        // cout<<endl;
    }

    // -------------------------------------Code ends here------------------------------------------------------------------

    clk = clock() - clk;
    // cerr << fixed << setprecision(6) << "Time: " << ((long double)clk) / CLOCKS_PER_SEC << "\n";
    return 0;
}


Measured memory_bytes: 663224