#!/usr/bin/env python3
from dataclasses import dataclass, field
from sys import stdin
from typing import IO, Iterator
from collections import deque


@dataclass
class TrieNode:
    id: int
    letter: str | None
    is_word_end: bool = False
    next_nodes: dict[str, "TrieNode"] = field(default_factory=dict)


def build_trie(file: IO[str]) -> tuple[TrieNode, int]:
    root = TrieNode(0, None)
    next_id = 1

    for line in file:
        line = line.strip().lower()
        if not line:
            continue

        node = root
        for char in line:
            if char in node.next_nodes:
                node = node.next_nodes[char]
            else:
                new_node = TrieNode(next_id, char)
                next_id += 1
                node.next_nodes[char] = new_node
                node = new_node

        node.is_word_end = True

    return root, next_id


@dataclass
class State:
    a: TrieNode
    b: TrieNode

    def to_int(self, node_count: int) -> int:
        return self.a.id + self.b.id * node_count

    def is_end(self) -> bool:
        return self.a.id != self.b.id and self.a.is_word_end and self.b.is_word_end

    def neighbours(self, root: TrieNode) -> Iterator["State"]:
        letters = self.a.next_nodes.keys() & self.b.next_nodes.keys()
        letters = sorted(letters)

        for letter in letters:
            yield State(self.a.next_nodes[letter], self.b.next_nodes[letter])

        if self.a.is_word_end:
            yield State(root, self.b)
        if self.b.is_word_end:
            yield State(self.a, root)
        if self.a.is_word_end and self.b.is_word_end:
            yield State(root, root)

    def last_letter(self) -> str:
        if self.a.letter is None or self.b.letter is None:
            return ""
        else:
            return self.a.letter


def find_word(root: TrieNode, node_count: int) -> str:
    state_count = node_count * node_count
    states = [None] * state_count

    start_state = State(root, root)
    states[start_state.to_int(node_count)] = start_state

    queue = deque([start_state])
    end_state = None

    while queue:
        state = queue.popleft()

        for neighbour in state.neighbours(root):
            if states[neighbour.to_int(node_count)] is not None:
                continue

            states[neighbour.to_int(node_count)] = state
            queue.append(neighbour)

        if state.is_end():
            end_state = state
            break
    else:
        raise RuntimeError("Language is unambiguous")

    visited_states = [end_state]

    while visited_states[-1] != start_state:
        prev_state = states[visited_states[-1].to_int(node_count)]
        visited_states.append(prev_state)

    visited_states = visited_states[::-1]
    return "".join(s.last_letter() for s in visited_states)


def main():
    root, node_count = build_trie(stdin)
    word = find_word(root, node_count)
    print(word)


if __name__ == "__main__":
    main()