#include <bits/stdc++.h>
using namespace std;

vector<vector<string>> groupAnagrams(const vector<string>& strs) {
    unordered_map<string, vector<string>> mp;
    for(const string& s : strs){
        string key = s;
        sort(key.begin(), key.end());
        mp[key].push_back(s);
    }
    vector<vector<string>> res;
    for(auto &p : mp){
        auto &group = p.second;
        sort(group.begin(), group.end()); // optional: deterministic order
        res.push_back(group);
    }
    // sort groups by first element for deterministic output
    sort(res.begin(), res.end(), [](const vector<string>& a, const vector<string>& b){
        return a[0] < b[0];
    });
    return res;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; if(!(cin>>n)) return 0;
    vector<string> strs(n);
    for(int i=0;i<n;++i) cin>>strs[i];
    auto groups = groupAnagrams(strs);
    for(const auto& g: groups){
        for(const auto& s: g) cout<<s<<' ';
        cout<<'\n';
    }
    return 0;
}

import java.util.*;

public class Main {
    public static List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for(String s : strs){
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String key = new String(chars);
            map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
        }
        List<List<String>> res = new ArrayList<>();
        for(List<String> group : map.values()){
            Collections.sort(group);
            res.add(group);
        }
        res.sort(Comparator.comparing(list -> list.get(0)));
        return res;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] strs = new String[n];
        for(int i=0;i<n;i++) strs[i] = sc.next();
        List<List<String>> groups = groupAnagrams(strs);
        for(List<String> g : groups){
            for(String s : g) System.out.print(s + " ");
            System.out.println();
        }
        sc.close();
    }
}

from typing import List
from collections import defaultdict

def group_anagrams(strs: List[str]) -> List[List[str]]:
    mp = defaultdict(list)
    for s in strs:
        key = ''.join(sorted(s))
        mp[key].append(s)
    groups = []
    for group in mp.values():
        group.sort()
        groups.append(group)
    groups.sort(key=lambda g: g[0])
    return groups

def main():
    import sys
    data = sys.stdin.read().strip().split()
    if not data:
        return
    n = int(data[0])
    strs = data[1:1+n]
    groups = group_anagrams(strs)
    for g in groups:
        print(' '.join(g))

if __name__ == "__main__":
    main()

function groupAnagrams(strs) {
    const map = new Map();
    for(const s of strs){
        const key = s.split('').sort().join('');
        if(!map.has(key)) map.set(key, []);
        map.get(key).push(s);
    }
    const groups = [];
    for(const arr of map.values()){
        arr.sort(); // deterministic order
        groups.push(arr);
    }
    groups.sort((a,b)=> a[0].localeCompare(b[0]));
    return groups;
}

// Driver (same as template)
function main(){
    const fs = require('fs');
    const input = fs.readFileSync(0,'utf8').trim().split(/\s+/);
    if(input.length===0) return;
    const n = parseInt(input[0],10);
    const strs = input.slice(1,1+n);
    const groups = groupAnagrams(strs);
    groups.forEach(g=> console.log(g.join(' ')));
}
main();