#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;            
}