#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>

using namespace std;

struct DSU {
    vector<int> parent;
    DSU(int n) {
        parent.resize(n);
        iota(parent.begin(), parent.end(), 0);
    }
    int find(int i) {
        if (parent[i] == i)
            return i;
        return parent[i] = find(parent[i]);
    }
    void unite(int i, int j) {
        int root_i = find(i);
        int root_j = find(j);
        if (root_i != root_j) {
            parent[root_i] = root_j;
        }
    }
};

// 字符串字典序比较
bool string_compare(const string& a, const string& b) {
    return a < b;
}

// 行间字典序比较
bool vector_compare(const vector<string>& a, const vector<string>& b) {
    return a < b;
}


int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int n;
    string line;
    getline(cin, line);
    n = stoi(line);

    vector<vector<string>> all_lines;
    map<string, int> id_map;
    int next_id = 0;

    for (int i = 0; i < n; ++i) {
        getline(cin, line);
        stringstream ss(line);
        string id;
        vector<string> current_line;
        while (ss >> id) {
            current_line.push_back(id);
            if (id_map.find(id) == id_map.end()) {
                id_map[id] = next_id++;
            }
        }
        all_lines.push_back(current_line);
    }

    if (next_id == 0) {
        return 0;
    }
    
    vector<string> name_map(next_id);
    for(auto const& [key, val] : id_map){
        name_map[val] = key;
    }

    DSU dsu(next_id);
    for (const auto& line_vec : all_lines) {
        if (line_vec.size() > 1) {
            int first_id = id_map[line_vec[0]];
            for (size_t i = 1; i < line_vec.size(); ++i) {
                dsu.unite(first_id, id_map[line_vec[i]]);
            }
        }
    }

    map<int, vector<string>> groups;
    for (int i = 0; i < next_id; ++i) {
        groups[dsu.find(i)].push_back(name_map[i]);
    }

    vector<vector<string>> result;
    for (auto const& [root, members] : groups) {
        vector<string> sorted_members = members;
        sort(sorted_members.begin(), sorted_members.end(), string_compare);
        result.push_back(sorted_members);
    }
    
    sort(result.begin(), result.end(), vector_compare);

    for (const auto& group : result) {
        for (size_t i = 0; i < group.size(); ++i) {
            cout << group[i] << (i == group.size() - 1 ? "" : " ");
        }
        cout << "\n";
    }

    return 0;
}

import java.util.*;

class DSU {
    private int[] parent;

    public DSU(int n) {
        parent = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    public int find(int i) {
        if (parent[i] == i) {
            return i;
        }
        return parent[i] = find(parent[i]);
    }

    public void unite(int i, int j) {
        int rootI = find(i);
        int rootJ = find(j);
        if (rootI != rootJ) {
            parent[rootI] = rootJ;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());

        List<String[]> allLines = new ArrayList<>();
        Map<String, Integer> idMap = new HashMap<>();
        int nextId = 0;

        for (int i = 0; i < n; i++) {
            String[] ids = sc.nextLine().split(" ");
            allLines.add(ids);
            for (String id : ids) {
                if (!idMap.containsKey(id)) {
                    idMap.put(id, nextId++);
                }
            }
        }
        
        if (nextId == 0) return;

        String[] nameMap = new String[nextId];
        for (Map.Entry<String, Integer> entry : idMap.entrySet()) {
            nameMap[entry.getValue()] = entry.getKey();
        }

        DSU dsu = new DSU(nextId);
        for (String[] line : allLines) {
            if (line.length > 1) {
                int firstId = idMap.get(line[0]);
                for (int i = 1; i < line.length; i++) {
                    dsu.unite(firstId, idMap.get(line[i]));
                }
            }
        }

        Map<Integer, List<String>> groups = new HashMap<>();
        for (int i = 0; i < nextId; i++) {
            int root = dsu.find(i);
            groups.putIfAbsent(root, new ArrayList<>());
            groups.get(root).add(nameMap[i]);
        }

        List<List<String>> result = new ArrayList<>();
        for (List<String> members : groups.values()) {
            // 行内字典序排序
            members.sort(String::compareTo);
            result.add(members);
        }

        // 行间字典序排序
        result.sort((l1, l2) -> {
            int size = Math.min(l1.size(), l2.size());
            for (int i = 0; i < size; i++) {
                int cmp = l1.get(i).compareTo(l2.get(i));
                if (cmp != 0) return cmp;
            }
            return Integer.compare(l1.size(), l2.size());
        });

        for (List<String> group : result) {
            System.out.println(String.join(" ", group));
        }
    }
}

class DSU:
    def __init__(self, n):
        self.parent = list(range(n))

    def find(self, i):
        if self.parent[i] == i:
            return i
        self.parent[i] = self.find(self.parent[i])
        return self.parent[i]

    def union(self, i, j):
        root_i = self.find(i)
        root_j = self.find(j)
        if root_i != root_j:
            self.parent[root_i] = root_j

def solve():
    n = int(input())
    all_lines = []
    id_map = {}
    next_id = 0

    for _ in range(n):
        ids = input().split()
        all_lines.append(ids)
        for id_str in ids:
            if id_str not in id_map:
                id_map[id_str] = next_id
                next_id += 1
    
    if next_id == 0:
        return

    name_map = {v: k for k, v in id_map.items()}

    dsu = DSU(next_id)
    for line in all_lines:
        if len(line) > 1:
            first_id = id_map[line[0]]
            for i in range(1, len(line)):
                dsu.union(first_id, id_map[line[i]])

    groups = {}
    for i in range(next_id):
        root = dsu.find(i)
        if root not in groups:
            groups[root] = []
        groups[root].append(name_map[i])
    
    result = []
    for root in groups:
        # 行内字典序排序
        sorted_members = sorted(groups[root])
        result.append(sorted_members)
        
    # 行间字典序排序 (Python默认的列表排序就是字典序)
    result.sort()

    for group in result:
        print(" ".join(group))

solve()