#include <bits/stdc++.h>
#define ll long long  
using namespace std;
ll help(ll n,vector<vector<ll>>&v,vector<ll>&dp,ll i)
{
    if(i>=n) return 0;
    if(dp[i]!=-1) return dp[i];
    ll t=help(n,v,dp,i+1);
    ll l=i+1;
    ll r=n-1;
    ll res=n;
    while(l<=r)
    {
        ll mid=(l+r)/2;
        if(v[mid][0]>=v[i][1])
        {
            res=mid;
            r=mid-1;
        }
        else l=mid+1;
    }
    ll next=res;
    ll sum=v[i][2]+v[i][1]-v[i][0];
    t=max(t,sum+help(n,v,dp,next));
    return dp[i]=t;
}
ll solve(vector<ll>&pick,vector<ll>&drop,vector<ll>&tip) 
{
    ll n=pick.size();
    vector<vector<ll>>rides(n);
    for(ll i=0;i<n;i++)
    {
        rides[i]={pick[i],drop[i],tip[i]};
    }
    sort(rides.begin(),rides.end());
    vector<ll>dp(n+10,-1);
    return help(n,rides,dp,0);
}
signed main() 
{
    ll n; cin>>n;
    vector<ll>pick(n),drop(n),tip(n);
    for(ll i=0;i<n;i++) cin>>pick[i];
    for(ll i=0;i<n;i++) cin>>drop[i];
    for(ll i=0;i<n;i++) cin>>tip[i];
    cout<<solve(pick,drop,tip);
    return 0;
}

#include <bits/stdc++.h>
#define ll long long  
using namespace std;
ll solve(vector<vector<ll>>&a) 
{
    ll n=a.size();
    if(a.empty())  return 0;
    ll sz=0,pre;
    vector<ll>cur(n);
    for(ll i=0;i<n;i++) 
    {
        for(ll j=0;j<n;j++) 
        {
            ll temp=cur[j];
            if (!i || !j || a[i][j]==0) 
            {
                cur[j]=a[i][j];
            } 
            else 
            {
                cur[j]=min(pre,min(cur[j],cur[j-1]))+1;
            }
            sz=max(cur[j],sz);
            pre=temp;
        }
    }
    return sz;
}
signed main() 
{
    ll n; cin>>n;
    vector<vector<ll>>a(n,vector<ll>(n));
    for(ll i=0;i<n;i++) 
     for(ll j=0;j<n;j++) cin>>a[i][j];
    cout<<solve(a);
    return 0;
}

def doesCircleExist(commands):
    def simulate(command):
        x, y = 0, 0
        dx, dy = 0, 1 
        for _ in range(4):  
            for c in command:
                if c == 'G':
                    x += dx
                    y += dy
                elif c == 'L':
                    dx, dy = -dy, dx
                elif c == 'R':
                    dx, dy = dy, -dx
            if x == 0 and y == 0:
                return True
            if dx == 0 and dy == 1:  
                return False
        return False

    results = []
    for command in commands:
        results.append("YES" if simulate(command) else "NO")
    return results

from collections import defaultdict

def maxShared(employees_nodes, employees_from, employees_to, employees_weight):
    graph = defaultdict(lambda: defaultdict(int))

    for i in range(len(employees_from)):
        u, v, w = employees_from[i], employees_to[i], employees_weight[i]
        graph[u][v] += 1
        graph[v][u] += 1
    
    max_product = 0
    
    for i in range(1, employees_nodes + 1):
        for j in graph[i]:
            if graph[i][j] > 1:  
                max_product = max(max_product, i * j)
    
    return max_product

def solve(N, K):
    MOD = 10**9 + 7
    if N > 10*K:
        return 0

    if N == 10*K:
        return 1

    dp = [1] + [0] * N

    for _ in range(10):
        new_dp = [0] * (N + 1)
        for i in range(N + 1):
            for j in range(min(K, N - i) + 1):
                new_dp[i + j] = (new_dp[i + j] + dp[i]) % MOD
        dp = new_dp
    
    return dp[N]

#include <bits/stdc++.h>
#define ll long long
using namespace std;
struct TrieNode {
    unordered_map<ll, TrieNode*> children;
    ll count;

    TrieNode() : count(0) {}
};
class Trie {
public:
    Trie() {
        root = new TrieNode();
    }
    void insert(vector<ll>& vector) 
{
        TrieNode* node = root;
        for (ll num : vector) {
            if (node->children.find(num) == node->children.end()) {
                node->children[num] = new TrieNode();
            }
            node = node->children[num];
            node->count++;
        }
    }
    ll countPrefix(vector<ll>& prefix) {
        TrieNode* node = root;
        for (ll num:prefix) 
      {
           if(num==-1) continue;
            if (node->children.find(num) == node->children.end()) {
                return 0;
             }
            node = node->children[num];
       }
        return node->count;
    }
private:
    TrieNode* root;
};
signed main() 
{
    ll n,m; cin>>n>>m;
vector<vector<ll>>a(n,vector<ll>(m));
for(ll i=0;i<n;i++)
{
  for(ll j=0;j<m;j++) cin>>a[i][j];
}
Trie trie;
    for(auto& vector:a) {
        trie.insert(vector);
    }
ll q; cin>>q;
vector<vector<ll>>qu(q);
for (ll i=0;i<q;i++) 
{
        ll num;
        while(cin>>num && num!=-1) 
  {
            qu[i].push_back(num);
        }
    }
for(auto&query:qu) 
{
        cout<<trie.countPrefix(query)<<endl;
    }

    return 0;            
}