import sys
import re


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.__counter = 0

    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()

    def addEdge(self, node1, node2, value):
        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] += int(value)
        #if i != j: self.__edges[j][i] += int(value)
        self.__counter += 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] != 0:
                    counter += 1
                arr[i] = counter
        maxi = (max(arr))
        for k in range(self.__num):
            if arr[k] == maxi:
                print(self.__nodes[k], "(" + str(maxi) + ")")

    def printEdge(self, i, j):
        print(self.__nodes[i], "-", self.__nodes[j])
 # (Jarnikuv-)Primuv(-Dijkstruv) algoritmus
    def launch(self):
        max = 1000
        noted = []
        helper1 = 0
        helper2 = 0
        while len(noted) != len(self.__nodes) and self.__counter >= 0:
            for i in range(self.__num):
                for j in range(self.__num):
                    if max > self.__edges[i][j] > 0 and (
                            self.__nodes[i] not in noted or self.__nodes[j] not in noted):
                        max = self.__edges[i][j]
                        helper1 = j
                        helper2 = i

            self.__edges[helper2][helper1] = 0
            if max != 1000 : self.printEdge(helper2, helper1)
            if self.__nodes[helper1] not in noted: noted.append(self.__nodes[helper1])
            if self.__nodes[helper2] not in noted: noted.append(self.__nodes[helper2])
            self.__counter -= 1
            max = 1000


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


read()