aa aaa aab aac aba abc

a: {
   a: {
      a: {},
      b: {},
      c: {},
   },
   b: {
      a: {},
      c: {},
   },
}

'''
С целью экономии чернил в картридже принтера было принято решение
укоротить некоторые слова в тексте. Для этого был составлен словарь слов,
до которых можно сокращать более длинные слова. Слово из текста можно
сократить, если в словаре найдется слово, являющееся началом слова из
текста. Например, если в списке есть слово "лом", то слова из текста
"ломбард", "ломоносов" и другие слова, начинающиеся на "лом", можно
сократить до "лом".

Если слово из текста можно сократить до нескольких слов из словаря, то следует сокращать его до самого короткого слова.
'''

class TrieNode:
    '''
    Класс узла префиксного дерева
    '''
    def __init__(self):
        # Словарь дочерних элементов (последующие буквы слова)
        # Например, для слов "a", "ab", "abc", "abd"
        # у узла "a" будет один дочерний узел "b",
        # у "b" - два дочерних узла "c" и "d".
        self.children = {}
        # Флаг, обозначающий конец слова
        self.is_end_of_word = False


class Trie:
    '''
    Класс префиксного дерева
    '''
    def __init__(self):
        # Корень дерева (элемент, с которого начинается поиск)
        self.root = TrieNode()

    def add_abbreviation_to_dict(self, abbreviation):
        '''
        Добавление аббревиатуры в словарь
        '''
        # Начинаем с корня
        node = self.root

        # Для каждой буквы аббревиатуры, если буква является 
        # дочерним узлом, переходим к узлу, иначе создаем новый узел
        for char in abbreviation:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        # После добавления всех букв аббревиатуры,
        # устанавливаем флаг конца слова
        node.is_end_of_word = True

    def find_abbreviation(self, word):
        '''
        Поиск аббревиатуры для слова
        '''
        # Начинаем с корня
        node = self.root

        # Для каждой буквы слова, проходимся по дочерним узлам
        # и добавляем букву в префикс, пока не найдем конец слова

        # Если буквы нет в дочерних узлах, возвращаем исходное слово
        prefix = ""
        for char in word:
            if char not in node.children:
                break
            node = node.children[char]
            prefix += char
            if node.is_end_of_word:
                return prefix
        return word

    def _str_helper(self, node, depth=0):
        '''
        Вспомогательный метод для вывода дерева в виде строки
        '''
        result = ""
        indent = "  " * depth
        for char, child_node in node.children.items():
            result += f"{indent}{char}\n"
            result += self._str_helper(child_node, depth + 1)
        return result

    def __str__(self):
        return self._str_helper(self.root)


# Алгоритм:
def abbreviate_words(dictionary, text):
    '''
    Функция сокращения слов в тексте
    '''
    trie = Trie()
    for word in dictionary:
        trie.add_abbreviation_to_dict(word)
    print(*trie.root.children)

    result = []
    for word in text:
        result.append(trie.find_abbreviation(word))

    return result

# Входные данные:
dictionary = input().split()
text = input().split()

# Вызов функции и вывод результата:
print(abbreviate_words(dictionary, text))

2X
1X

class Rectangle:
    '''
    Класс для работы с прямоугольником
    '''
    def __init__(self, p1, p2):
        self.point1 = p1
        self.point2 = p2

    def get_possible_points(self):
        '''
        Получение возможных точек прямоугольника
        '''
        diff_x = self.point2[0] - self.point1[0]
        diff_y = self.point2[1] - self.point1[1]

        possible_points = [
            # прямоугольник по стороне 1 (по часовой стрелке)
            (self.point2[0] + diff_y, self.point2[1] - diff_x),
            (self.point1[0] + diff_y, self.point1[1] - diff_x),

            # прямоугольник по стороне 2 (против часовой стрелке)
            (self.point2[0] - diff_y, self.point2[1] + diff_x),
            (self.point1[0] - diff_y, self.point1[1] + diff_x),
        ]

        # прямоугольник по диагонали
        diff_x1 = diff_x + diff_y
        diff_y1 = diff_x - diff_y
        if diff_x1 % 2 == 0 and diff_y1 % 2 == 0:
            possible_points.append(
                (self.point1[0] + diff_y1 // 2, self.point1[1] + diff_x1 // 2)
            )
            possible_points.append(
                (self.point1[0] + diff_x1 // 2, self.point1[1] - diff_y1 // 2)
            )

        return possible_points

# Входные данные:
# Количество точек
N = int(input())

points = set()

# Множество точек
for i in range(N):
    X, Y = map(int, input().split())
    points.add((X, Y))

# Алгоритм:
# Если в множестве всего одна точка, то добавляем 3 точки
# вверх, вправо и по диагонали
if N == 1:
    print(3)
    point = points.pop()
    print(f"{point[0] + 1} {point[1]}")
    print(f"{point[0]} {point[1] + 1}")
    print(f"{point[0] + 1} {point[1] + 1}")

# Если в множестве две точки, то добавляем две точки как минимум
else:
    # Минимальное количество точек, которое нужно добавить
    min_points_count = 2

    # Точка, которую нужно добавить, если есть три точки
    min_points = []

    # Перебираем все точки
    for point1 in points:
        for point2 in points:
            if point1 == point2:
                continue
            rectangle = Rectangle(point1, point2)

            # Получаем возможные точки прямоугольника
            possible_points = rectangle.get_possible_points()

            # Проверяем, есть ли эти точки в множестве
            r11 = possible_points[0] in points
            r12 = possible_points[1] in points

            r21 = possible_points[2] in points
            r22 = possible_points[3] in points

            # Если есть 6 точек, то проверяем еще две точки (по диагонали)
            if len(possible_points) == 6:
                r31 = possible_points[4] in points
                r32 = possible_points[5] in points
            else:
                r31 = False
                r32 = False


            # Если есть 2 точки, то выходим из цикла
            if r11 and r12:
                min_points_count = 0
                break

            if r21 and r22:
                min_points_count = 0
                break
            if r31 and r32:
                min_points_count = 0
                break

            # Иначе, если есть одна точка, то добавляем ее
            if min_points_count == 2:
                if r11 or r12:
                    min_points_count = 1
                    min_points = [possible_points[0] if r12 else possible_points[1]]

                elif r21 or r22:
                    min_points_count = 1
                    min_points = [possible_points[2] if r22 else possible_points[3]]

                elif r31 or r32:
                    min_points_count = 1
                    min_points = [possible_points[4] if r32 else possible_points[5]]

        # Если нашли две точки, то выходим из цикла
        if min_points_count == 0:
            min_points = []
            break

    # Выводим результат
    print(min_points_count)
    if min_points_count == 2:
        rectangle = Rectangle(points.pop(), points.pop())
        min_points = rectangle.get_possible_points()[:2]
    for point in min_points:
        print(f"{point[0]} {point[1]}")

            vec1 = (match1[0] - match1[2], match1[1] - match1[3])
            vec2 = (match2[0] - match2[2], match2[1] - match2[3])

'''
Головоломки, которые решает Вася, всегда имеют решение. Это значит, что
набор спичек, используемый в изображении A, совпадает с набором спичек,
используемым в изображении B. Кроме того, в одном изображении никогда не
встречаются две спички, у которых есть общий участок ненулевой длины (то
есть спички могут пересекаться, но не могут накладываться друг на друга).

Вася устал решать головоломки вручную, и теперь он просит вас написать,
программу, которая будет решать головоломки за него. Программа будет
получать описания изображений A и B и должна найти минимальное
количество спичек, которые надо переложить в изображении A, чтобы
полученная картинка получалась из B параллельным переносом.
'''

# Входные данные:
# N - количество спичек в изображении
N = int(input())

matches1 = set()
matches2 = set()

# Считываем спички и сразу сортируем их, так чтобы
# спичка смотрела в направлении от севера до востока
for i in range(N):
    X1, Y1, X2, Y2 = map(int, input().split())
    if X1 > X2 or (X1 == X2 and Y1 > Y2):
        X1, Y1, X2, Y2 = X2, Y2, X1, Y1
    matches1.add(((X1, Y1, X2, Y2)))

for i in range(N):
    X1, Y1, X2, Y2 = map(int, input().split())
    if X1 > X2 or (X1 == X2 and Y1 > Y2):
        X1, Y1, X2, Y2 = X2, Y2, X1, Y1
    matches2.add((X1, Y1, X2, Y2))

# Алгоритм:
# Количество совпадающих спичек
matches_count = 0
# Словарь для хранения совпадений
dict_matches = {}

# Если изображения совпадают, то ничего не нужно делать
if matches1 == matches2:
    print(0)
else:
    for match1 in matches1:
        for match2 in matches2:
            vec1 = (match1[0] - match1[2], match1[1] - match1[3])
            vec2 = (match2[0] - match2[2], match2[1] - match2[3])
            if vec1 == vec2:
                diff = (match1[0] - match2[0], match1[1] - match2[1])
                dict_matches[diff] = dict_matches.get(diff, 0) + 1

    if not dict_matches:
        print(N)
    else:
        good_diff = max(dict_matches, key=dict_matches.get)
        new_mathes = set(
            (
                (
                    match2[0] + good_diff[0],
                    match2[1] + good_diff[1],
                    match2[2] + good_diff[0],
                    match2[3] + good_diff[1],
                )
                for match2 in matches2
            )
        )
        print(new_mathes)
        matches_count = len(matches1 & new_mathes)

        print(N - matches_count)