import sys
import re
from copy import deepcopy

class Graf:
    def __init__(self, nodes=[]):
        self.__nodes = nodes
        self.__num = len(nodes)
        self.__countEdge = 0
        self.__edges = [[0 for i in range(self.__num)] for j in range(self.__num)]
        self.__edges2 = [[0 for i in range(self.__num)] for j in range(self.__num)]


    def __repr__(self):
        return f * Graf(nodes=(self.__nodes))

    def addNode(self, node):
        return Graf(nodes=self.__nodes + [node])

    def print(self):
        # sys.stdout.write(self.__nodes)
        print(self.__nodes)
        for i in self.__edges:
            for j in i:
                print(j, end=" ")
            print()
        """
        print("---------------------")
        for i in self.__edges2:
            for j in i:
                print(j, end=" ")
            print()
        """
    def addEdge(self, node1, node2):
        i = 0
        j = 0
        for k in range(self.__num):
            if self.__nodes[k] == node1:
                i = k
            if self.__nodes[k] == node2:
                j = k
        self.__edges[i][j] = 1
        if i != j: self.__edges[j][i] = -1
        self.__countEdge += 1

    def printEdge(self, i, j):
        print(self.__nodes[i], "->", self.__nodes[j])

    def weakness(self):
        self.arti()



    def arti(self):
        for k in range(self.__num):
            helper = deepcopy(self.__edges)
            for i in range(self.__num):
                for j in range(self.__num):
                    if helper[i][j] != 0 and (i == k or j == k):
                        helper[i][j] = 0
            if not self.isOneGraph(helper, k):
                print(self.__nodes[k])

    def bridges(self):
        start = []
        end = []
        for i in range(self.__num):
            for j in range(self.__num):
                if self.__edges[i][j] != 0:
                    start.append(i)
                    end.append(j)

        for k in range(len(start)):

            helper = self.__edges[start[k]][end[k]]
            self.__edges[start[k]][end[k]] = 0
            visited = [0]
            for i in visited:
                counter = self.__countEdge
                for j in range(self.__num):
                    if self.__edges[i][j] != 0:
                        if j not in visited:
                            visited.append(j)
                if len(visited) == self.__num: break
            self.__edges[start[k]][end[k]] = helper
            if len(visited) != self.__num:
                self.printEdge(start[k], end[k])


    def isOneGraph(self, edges, index):
        if index != 0: visited = [0]
        else: visited = [1]
        border = self.__num
        counter = 0
        for j in visited:
            for i in range(self.__num):
                if edges[j][i] != 0:
                    if index != 0:
                        if j != index and i != index:
                            if i not in visited:
                                visited.append(i)
                    elif i not in visited:visited.append(i)
            if len(visited) == self.__num-1: break
            if counter == border: break
            counter += 1
        if len(visited) == self.__num-1 : return True
        return False

    def edges(self):
        return self.__edges


def read():
    counter = 0
    g1 = Graf([])
    for line in sys.stdin:
        if line == "exit\n" or line == "\n":
            break
        if counter == 0:
            line = line.replace("City: ", "")
            line = line.replace("\n", "")
            nodes = line.split(", ")
            for i in nodes:
                g1 = g1.addNode(i)
            counter += 1
        else:
            line = re.sub(r'(.)*: ', '', line)
            line = line.replace("\n", "")
            edges = line.split("->")
            for i in range(len(edges) - 1):
                g1.addEdge(str(edges[i]).strip(), str(edges[i + 1]).strip())
    #g1.print()
    #g1.weakness()
    #g1.print()
    #g1.print()
    g1.bridges()
    #print(g1.isOneGraph(g1.edges(),0))


read()