#include <bits/stdc++.h>
using namespace std;

int main() {
    static const int maxk = 18, maxu = 150;
    int k;
    scanf("%d", &k);
    static int v[1 << maxk];
    static int nxt[maxu][2], id[maxu], cnt = 1;
    nxt[1][0] = ++cnt, nxt[1][1] = ++cnt;
    for (int i = 0; i < k; i++) {
        static char s[maxu];
        scanf("%s", s + 1), scanf("%d", v + (1 << i));
        int l = strlen(s + 1), u = 1;
        for (int p = 1; p <= l; p++) {
            int d = s[p] == '1';
            if (!nxt[u][d])
                nxt[u][d] = ++cnt;
            u = nxt[u][d];
        }
        id[u] ^= 1 << i;
    }
    queue<int> Q;
    static int fa[maxu], dep[maxu];
    for (int i : nxt[1]) fa[i] = dep[i] = 1, Q.push(i);
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();
        for (int d = 0; d < 2; d++)
            if (nxt[u][d])
                dep[nxt[u][d]] = dep[fa[nxt[u][d]] = nxt[fa[u]][d]] + 1, Q.push(nxt[u][d]);
            else
                nxt[u][d] = nxt[fa[u]][d];
    }
    static int c[maxu], ord[maxu];
    for (int i = 1; i <= cnt; i++) c[dep[i]]++;
    for (int i = 1; i <= cnt; i++) c[i] += c[i - 1];
    for (int i = 1; i <= cnt; i++) ord[c[dep[i]]--] = i;
    for (int i = 1; i <= cnt; i++) id[ord[i]] |= id[fa[ord[i]]];
    for (int s = 1; s < 1 << k; s++) v[s] = v[s ^ (s & -s)] + v[s & -s];
    static int dp[1 << maxk][maxu];
    for (int s = (1 << k) - 2; s >= 0; s--) {
        static int deg[maxu];
        static vector<int> G[maxu];
        memset(dp[s], 0xcf, sizeof(dp[s]));
        for (int u = 1; u <= cnt; u++) deg[u] = 0, G[u].clear();
        for (int u = 1; u <= cnt; u++) {
            int t0 = nxt[u][0], t1 = nxt[u][1];
            if (id[t0] & ~s)
                dp[s][u] = max(dp[s][u], v[id[t0] & ~s] - dp[s | id[t0]][t0]);
            else
                G[t0].push_back(u), deg[u]++;
            if (id[t1] & ~s)
                dp[s][u] = max(dp[s][u], v[id[t1] & ~s] - dp[s | id[t1]][t1]);
            else
                G[t1].push_back(u), deg[u]++;
        }
        struct node {
            int u, d;
            inline bool operator<(const node rhs) const { return abs(d) < abs(rhs.d); }
        };
        priority_queue<node> Q;
        static bool vis[maxu];
        memset(vis, 0, sizeof(vis));
        for (int u = 1; u <= cnt; u++)
            if (!deg[u] || dp[s][u] > 0)
                Q.push({ u, dp[s][u] });
        while (!Q.empty()) {
            int u = Q.top().u;
            Q.pop();
            if (vis[u])
                continue;
            vis[u] = true;
            for (int i : G[u]) {
                dp[s][i] = max(dp[s][i], -dp[s][u]);
                if (!(--deg[i]) || dp[s][i] > 0)
                    Q.push({ i, dp[s][i] });
            }
        }
        for (int u = 1; u <= cnt; u++)
            if (deg[u])
                dp[s][u] = max(dp[s][u], 0);
    }
    int q;
    scanf("%d", &q);
    while (q--) {
        static char s[maxu];
        scanf("%s", s + 1);
        int l = strlen(s + 1), S = 0, u = 1;
        for (int i = 1; i <= l; i++) S |= id[u = nxt[u][s[i] == '1']];
        printf("%d\n", dp[S][u]);
    }
    return 0;
}