#!/bin/python3

import math
import os
import random
import re
import sys

sys.setrecursionlimit(1000)
class Node:
    def __init__(self, key, value):
        self.key = key
        self.val = value
        self.left = None
        self.right = None
        self.height = 0

class AVL:

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

    def insert(self, root, key, value):

        if not root:
            self.size+=1
            return Node(key, value)
        elif key < root.key:
            root.left = self.insert(root.left, key, value)
        elif key > root.key:
            root.right = self.insert(root.right, key, value)
        elif key == root.key and hasattr(root.val, "append"):
            root.val.append(value)

        root.height = 1 + max(self.getHeight(root.left),
                           self.getHeight(root.right))

        balance = self.getBalance(root)

        if balance > 1:
            if key > root.left.key:
                root.left = self.leftRotate(root.left)
                return self.rightRotate(root)
            elif key < root.left.key:
                return self.rightRotate(root)
        elif balance < -1:
            if key > root.right.key:
                return self.leftRotate(root)
            elif key < root.right.key:
                root.right = self.rightRotate(root.right)
                return self.leftRotate(root)

        return root

    def leftRotate(self, z):

        y = z.right
        T2 = y.left
        y.left = z
        z.right = T2
        z.height = 1 + max(self.getHeight(z.left),
                         self.getHeight(z.right))
        y.height = 1 + max(self.getHeight(y.left),
                         self.getHeight(y.right))
        return y

    def rightRotate(self, z):

        y = z.left
        T3 = y.right

        y.right = z
        z.left = T3
        z.height = 1 + max(self.getHeight(z.left),
                        self.getHeight(z.right))
        y.height = 1 + max(self.getHeight(y.left),
                        self.getHeight(y.right))
        return y

    def hint_all_keys(self, node):
        if node is not None:
            self.hint_all_keys(node.left)
            print(node.value, end=" ")
            self.hint_all_keys(node.right)

    def get_all_keys(self, node):
        self.arr = []
        self.het_all_keys(node, self.arr)
        return self.arr

    def het_all_keys(self, node, arr):
        if node.left is not None:
            self.het_all_keys(node.left, arr)
        arr.append(node.value)
        if node.right is not None:
            self.het_all_keys(node.right, arr)

    def get_all_keyvalues(self, node):
        self.arr = []
        self.het_all_keyvalues(node, self.arr)
        return self.arr

    def het_all_keyvalues(self, node, arr):
        if node.left is not None:
            self.het_all_keyvalues(node.left, arr)
        arr.append(node)
        if node.right is not None:
            self.het_all_keyvalues(node.right, arr)

    def getHeight(self, root):
        if not root:
            return 0
        return root.height

    def getBalance(self, root):
        if not root:
            return 0
        return self.getHeight(root.left) - self.getHeight(root.right)


    def search(self, value):
        node = self.root

        while True:
            if node.key > value:
                if node.left is not None:
                    node = node.left
                else:
                    return -1
            elif node.key < value:
                if node.right is not None:
                    node = node.right
                else:
                    return -1
            elif node.key == value:
                return node.val


    def get_all_keyvalues(self, node):
        if node is None:
            return
        yield from self.get_all_keyvalues(node.left)
        yield node
        yield from self.get_all_keyvalues(node.right)

    def singleRightRotate(self, node):
        l = node.left
        node.left = l.right
        l.right = node
        node.height = max(self.height(node.left), self.height(node.right)) + 1
        l.height = max(self.height(l.left), node.height) + 1
        return l

    def singleLeftRotate(self, node):
        r = node.right
        node.right = r.left
        r.left = node
        node.height = max(self.height(node.left), self.height(node.right))
        r.height = max(self.height(r.right), node.height + 1)
        return r

    def doubleLeftRotate(self, node):
        node.left = self.singleRightRotate(node.left)
        return self.singleLeftRotate(node)

    def doubleRightRotate(self, node):
        node.left = self.singleLeftRotate(node.left)
        return self.singleRightRotate(node)

    def set(self, key, value):
        self.root = self.insert(self.root, key, value)

    def get(self, value):
        return self.search(value)

    def get_keys(self):
        for node in self.get_all_keyvalues(self.root):
            yield node.key


class Set:
    def __init__(self, value):
        self.tree = AVL()
        self.tree.set(value, "present")

    def append(self, hash_set):
        key = hash_set.get_first()
        self.tree.set(key, "present")

    def get_all_values(self):
        string = ""
        for key in self.tree.get_keys():
            string += str(key) + " "
        return string

    def get_first(self):
        return self.tree.root.key

    def count(self):
        return self.tree.size


class InvertedIndex:
    def __init__(self):
        self.tree = AVL()

    def index_document(self, document, document_id):
        words = document.split(" ")
        for word in words:
           # print(self.tree.root)
            self.tree.set(word, Set(document_id))

    def get_average(self):
        sum = 0
        count = 0
        arr = []
        for node in self.tree.get_all_keyvalues(self.tree.root):
            sum += node.val.count()
            count += 1
            arr.append(node.key)
        return arr, int(round(sum/count, 0))

    def search(self, word):
        node = self.tree.get(word)
        if node != -1:
            node = node.get_all_values()
        return node




if __name__ == '__main__':
    num_documents = int(input().strip())

    documents = []

    for _ in range(num_documents):
        documents_item = input()
        documents.append(documents_item)

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

    queries = []

    for _ in range(num_queries):
        queries_item = input()
        queries.append(queries_item)

    index = InvertedIndex()
    try:
        for i in range(num_documents):
            index.index_document(documents[i], i)
    except Exception:
        pass
    for word in queries:
        print(index.search(word))
    aver = index.get_average()
    print(aver[1])

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

    if should_print_keys:
        for word in aver[0]:
            print(word, end=" ")