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

int main() {
    int n;
    scanf("%d", &n);
    vector<string> names(n);
    for (int i = 0; i < n; i++) {
        char buf[1001];
        scanf("%s", buf);
        names[i] = buf;
    }

    // 将字符串拆分为交替的非数字段和数字段
    auto parse = [](const string& s) -> vector<pair<string, long long>> {
        vector<pair<string, long long>> segs;
        int i = 0, len = s.size();
        while (i < len) {
            if (isdigit(s[i])) {
                int j = i;
                while (j < len && isdigit(s[j])) j++;
                segs.push_back({s.substr(i, j - i), stoll(s.substr(i, j - i))});
                i = j;
            } else {
                int j = i;
                while (j < len && !isdigit(s[j])) j++;
                segs.push_back({s.substr(i, j - i), -1}); // -1 表示非数字段
                i = j;
            }
        }
        return segs;
    };

    vector<int> idx(n);
    iota(idx.begin(), idx.end(), 0);
    vector<vector<pair<string, long long>>> parsed(n);
    for (int i = 0; i < n; i++) parsed[i] = parse(names[i]);

    stable_sort(idx.begin(), idx.end(), [&](int a, int b) {
        auto& sa = parsed[a];
        auto& sb = parsed[b];
        int m = min(sa.size(), sb.size());
        for (int i = 0; i < m; i++) {
            bool aDigit = (sa[i].second >= 0);
            bool bDigit = (sb[i].second >= 0);
            if (aDigit != bDigit) return aDigit; // 数字段排前面
            if (aDigit) {
                if (sa[i].second != sb[i].second)
                    return sa[i].second < sb[i].second;
            } else {
                if (sa[i].first != sb[i].first)
                    return sa[i].first < sb[i].first;
            }
        }
        return sa.size() < sb.size();
    });

    for (int i = 0; i < n; i++) printf("%s\n", names[idx[i]].c_str());
    return 0;
}

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine().trim());
        String[] names = new String[n];
        for (int i = 0; i < n; i++) names[i] = br.readLine().trim();

        // 预处理：将每个文件名拆分为段
        List<List<String>> segs = new ArrayList<>();
        List<List<Boolean>> types = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            List<String> seg = new ArrayList<>();
            List<Boolean> typ = new ArrayList<>();
            int j = 0, len = names[i].length();
            while (j < len) {
                if (Character.isDigit(names[i].charAt(j))) {
                    int k = j;
                    while (k < len && Character.isDigit(names[i].charAt(k))) k++;
                    seg.add(names[i].substring(j, k));
                    typ.add(true);
                    j = k;
                } else {
                    int k = j;
                    while (k < len && !Character.isDigit(names[i].charAt(k))) k++;
                    seg.add(names[i].substring(j, k));
                    typ.add(false);
                    j = k;
                }
            }
            segs.add(seg);
            types.add(typ);
        }

        Integer[] idx = new Integer[n];
        for (int i = 0; i < n; i++) idx[i] = i;

        Arrays.sort(idx, (a, b) -> {
            List<String> sa = segs.get(a), sb = segs.get(b);
            List<Boolean> ta = types.get(a), tb = types.get(b);
            int m = Math.min(sa.size(), sb.size());
            for (int i = 0; i < m; i++) {
                boolean ad = ta.get(i), bd = tb.get(i);
                if (ad != bd) return ad ? -1 : 1;
                if (ad) {
                    long va = Long.parseLong(sa.get(i));
                    long vb = Long.parseLong(sb.get(i));
                    if (va != vb) return Long.compare(va, vb);
                } else {
                    int cmp = sa.get(i).compareTo(sb.get(i));
                    if (cmp != 0) return cmp;
                }
            }
            return sa.size() - sb.size();
        });

        StringBuilder out = new StringBuilder();
        for (int i = 0; i < n; i++) out.append(names[idx[i]]).append('\n');
        System.out.print(out);
    }
}

import sys
from functools import cmp_to_key

def parse(s):
    segs = []
    i = 0
    while i < len(s):
        if s[i].isdigit():
            j = i
            while j < len(s) and s[j].isdigit():
                j += 1
            segs.append((True, int(s[i:j]), s[i:j]))
            i = j
        else:
            j = i
            while j < len(s) and not s[j].isdigit():
                j += 1
            segs.append((False, 0, s[i:j]))
            i = j
    return segs

def compare(a, b):
    sa, sb = a[1], b[1]
    m = min(len(sa), len(sb))
    for i in range(m):
        ad, av, at = sa[i]
        bd, bv, bt = sb[i]
        if ad != bd:
            return -1 if ad else 1  # 数字段排前面
        if ad:  # 都是数字段，比数值
            if av != bv:
                return -1 if av < bv else 1
        else:  # 都是字符串段，比字典序
            if at != bt:
                return -1 if at < bt else 1
    if len(sa) != len(sb):
        return -1 if len(sa) < len(sb) else 1
    return 0

input_data = sys.stdin.read().split('\n')
n = int(input_data[0])
names = []
for i in range(1, n + 1):
    s = input_data[i].strip()
    names.append((s, parse(s)))

names.sort(key=cmp_to_key(compare))
print('\n'.join(name for name, _ in names))

const readline = require('readline');
const rl = readline.createInterface({ input: process.stdin });
const lines = [];

rl.on('line', line => lines.push(line.trim()));
rl.on('close', () => {
    const n = parseInt(lines[0]);
    const names = [];
    for (let i = 1; i <= n; i++) names.push(lines[i]);

    function parse(s) {
        const segs = [];
        let i = 0;
        while (i < s.length) {
            if (s[i] >= '0' && s[i] <= '9') {
                let j = i;
                while (j < s.length && s[j] >= '0' && s[j] <= '9') j++;
                segs.push({ isDigit: true, num: parseInt(s.substring(i, j)), text: s.substring(i, j) });
                i = j;
            } else {
                let j = i;
                while (j < s.length && !(s[j] >= '0' && s[j] <= '9')) j++;
                segs.push({ isDigit: false, num: 0, text: s.substring(i, j) });
                i = j;
            }
        }
        return segs;
    }

    const parsed = names.map(s => parse(s));
    const idx = Array.from({ length: n }, (_, i) => i);

    idx.sort((a, b) => {
        const sa = parsed[a], sb = parsed[b];
        const m = Math.min(sa.length, sb.length);
        for (let i = 0; i < m; i++) {
            if (sa[i].isDigit !== sb[i].isDigit) return sa[i].isDigit ? -1 : 1;
            if (sa[i].isDigit) {
                if (sa[i].num !== sb[i].num) return sa[i].num - sb[i].num;
            } else {
                if (sa[i].text !== sb[i].text) return sa[i].text < sb[i].text ? -1 : 1;
            }
        }
        return sa.length - sb.length;
    });

    const result = [];
    for (let i = 0; i < n; i++) result.push(names[idx[i]]);
    console.log(result.join('\n'));
});