#!/bin/python3

import math
import os
import random
import re
import sys

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.left = None
        self.right = None
        self.level = None
        self.height= 0

    def __str__(self):
        return str(self.value)

class AVLSet:
    def __init__(self):
        self.avltree = AVLTree()
        self.present = object()

    def add(self, value):
        self.avltree[value] = self.present

    def __contains__(self, value):
        try:
            _ = self.avltree[value]
            return True
        except KeyError:
            return False

    def __str__(self):
        return self.printset(self.avltree.root)

    def printset(self, node):
        s=""
        if node is None:
            return ""
        s=s+self.printset(node.left)
        s=s+str(node.key)+" "
        s=s+self.printset(node.right)
        return s

    def amount(self):
        return self.avltree.size

class AVLTree:
    def __init__(self):
        self.root = None
        self.size=0

    def __setitem__(self, key, value):
        if self.root == None:
            self.root = Node(key, value)
            self.size+=1
        else:
            current = self.root
            while True:
                if key < current.key:
                    if current.left:
                        current = current.left
                    else:
                        current.left = Node(key, value)
                        self.size+=1
                        break
                elif key > current.key:
                    if current.right:
                        current = current.right
                    else:
                        current.right = Node(key, value)
                        self.size+=1
                        break
                else:
                    break
        self.root=self.rebalance(key, self.root)


    def __getitem__(self, key):
        current=self.root
        while True:
            if key < current.key:
                current = current.left
            elif key > current.key:
                current = current.right
            else:
                return current.value


    def rebalance(self, key, current):
        if key > current.key:
            current.right.height+=1
            current.right=self.rebalance(key, current.right)
        elif key < current.key:
            current.left.height+=1
            current.left=self.rebalance(key, current.left)
        if (self.balance(current)==-2 and self.balance(current.left)==-1):
            current=self.right_rotation(current)
        elif (self.balance(current)==-2 and self.balance(current.left)==1):
            current.left=self.left_rotation(current.left)
            current=self.right_rotation(current)
        elif (self.balance(current)==2 and self.balance(current.right)==1):
            current=self.left_rotation(current)
        elif (self.balance(current)==2 and self.balance(current.right)==-1):
            current.right=self.right_rotation(current.right)
            current=self.left_rotation(current)
        return current


    def balance(self, node):
        if node is None:
            return 0
        elif node.right is None and node.left is None:
            return 0
        elif node.right is None:
            return -1 - node.left.height
        elif node.left is None:
            return node.right.height+1
        else: return node.right.height - node.left.height

    def left_rotation(self, node):
        A=Node(node.key, node.value)
        A.left=node.left
        if node.right is not None:
            A.right=node.right.left
            node=node.right
            node.left=A
        return node


    def right_rotation(self, node):
        A=Node(node.key, node.value)
        A.right=node.right
        if node.left is not None:
            A.left=node.left.right
            node=node.left
            node.right=A
        return node



    def __contains__(self, key):
        current=self.root
        while True:
            if current==None:
                return False
            elif key < current.key:
                current = current.left
            elif key > current.key:
                current = current.right
            else:
                return True



class Inverted_Index:
    def __init__(self, tree):
        self.tree=tree

    def index_document(self, document, document_id):
        s=document.split()
        for k in s:
            avlset=AVLSet()
            if k in self.tree:
                self.tree[k].add(document_id)
            else:
                avlset.add(document_id)
                self.tree[k] = avlset

    def search(self, word):
        if word in self.tree:
            return self.tree[word]
        else: return -1

    def get_average_main(self):
        return int(round(self.get_average(self.tree.root)/self.tree.size))

    def get_average(self, node):
        c=0
        if node is None:
            return 0
        c=c+self.get_average(node.left)
        c=c+node.value.amount()
        c=c+self.get_average(node.right)
        return c

    def print_keys_main(self):
        return self.print_keys(self.tree.root)

    def print_keys(self, node):
        s=""
        if node is None:
            return ""
        s=s+self.print_keys(node.left)
        s=s+str(node.key)+" "
        s=s+self.print_keys(node.right)
        return s

if __name__ == '__main__':
    num_documents = int(input().strip())
    tree1=AVLTree()
    ii = Inverted_Index(tree1)
    for i in range(num_documents):
        documents_item = input()
        ii.index_document(documents_item, i)

    num_queries = int(input().strip())


    for _ in range(num_queries):
        queries_item = input()
        print(ii.search(queries_item))

    print(ii.get_average_main())

    try:
        print_keys_flag = input()
        should_print_keys = print_keys_flag == 'print_keys'
    except:
        should_print_keys = False

    if should_print_keys:
        print(ii.print_keys_main())