import sys
import re
import random

class Graf:
    def __init__(self, nodes=[]):
        self.__nodes = nodes
        self.__num = len(nodes)
        self.__edges = [[0 for i in range(self.__num)] for j in range(self.__num)]
        self.__edgesFlag = [["no" 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)
        print(len(self.__nodes))
        for i in self.__edges:
            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


    # spocita stupen uzlu a vypise nejvyssi
    def countNodeDegree(self):
        arr = []
        arr = [0 for i in range(self.__num)]
        for i in range(self.__num):
            counter = 0
            for j in range(self.__num):
                if self.__edges[i][j] == 1:
                    counter += 1
                arr[i] = counter
        #maxi = (max(arr))
        #for k in range(self.__num):
            #if arr[k] == maxi:
                #print(self.__nodes[k], "(" + str(maxi) + ")")
        #return arr

    def printEdge(self, i, j):
        final = ''
        final += (self.__nodes[i])
        final += " -> "
        final += self.__nodes[j]
        final += '\n'
        return final

    def escape(self):

        start = self.__nodes[0]
        end = self.__nodes[len(self.__nodes) - 1]
        actual = start
        actualIndex = 0
        helper = False
        final = ''
        while not helper:
            if actual == end:
                helper = True
                print(final)
                break
            unmarked = True
            inHelper = False
            inIndex = 10000
            index = 10000
            for j in range(self.__num):
                if self.__edges[actualIndex][j] == 1:
                    if self.__edgesFlag[actualIndex][j] != "no":
                        unmarked = False
                    else: index = j
                    if self.__edgesFlag[actualIndex][j] == "in":
                        inHelper = True
                        inIndex = j
            if unmarked:
                self.__edgesFlag[actualIndex][index] = "in"
                self.__edgesFlag[index][actualIndex] = "in"
                final += self.printEdge(actualIndex, index)
                actual = self.__nodes[index]
                actualIndex = index
            elif index != 10000:
                self.__edgesFlag[actualIndex][index] = "out"
                self.__edgesFlag[index][actualIndex] = "out"
                final += self.printEdge(actualIndex, index)
                actual = self.__nodes[index]
                actualIndex = index
            elif inHelper:
                actual = self.__nodes[inIndex]
                final += self.printEdge(actualIndex, inIndex)
                actualIndex = inIndex
            elif not inHelper:
                helper = True
                print("Z bludiste neni vychod")

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("Sections: ", "")
            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.escape()



read()