#include "bits/stdc++.h"

using namespace std;

    class Graph{
    public:


        Graph(int size) : isVisitedTop(size, false){
            for(int i = 0; i < size; ++i){
                matrix.push_back(vector<int>(size,0));
                string s;
                cout << "Enter name v : ";
                cin >> s;
                IndexToName.push_back(s);
                NameToIndex[s] = i;
            }
        }

        auto First(string v){
            if(!matrix[NameToIndex[v]].empty()){
                if(NameToIndex[v] >= matrix.size())
                    throw runtime_error("going beyond the boundaries of the matrix");
                else{
                    for(int i = 0; i < matrix[NameToIndex[v]].size(); ++i){
                        if(matrix[NameToIndex[v]][i] != 0)
                            return i;
                    }
                    return -1;
                }
            } else
                throw runtime_error("height does not exist");
        }

        auto Next(string v, int i){
            if(!matrix[NameToIndex[v]].empty()){
                if(i == matrix[NameToIndex[v]].size() - 1){
                    return -1;
                }
                for(int x = i + 1; i < matrix[0].size(); ++i){
                    if(matrix[NameToIndex[v]][x] != 0)
                        return x;
                }
                return -1;
            }
            else
                throw runtime_error("height does not exist");
        }

        string Vertex(string v, int i) {
            if(!matrix[NameToIndex[v]].empty()){
                if (matrix[NameToIndex[v]][i])
                    return IndexToName[i];
            }
            else throw runtime_error("height does not exist");

        }

        void Add_V(string v){
            NameToIndex[v] = matrix.size();
            IndexToName.push_back(v);
            matrix.push_back(vector<int>(matrix[0].size(), 0));
            for(auto& x : matrix) {
                if(!x.empty())
                    x.push_back(0);
            }
        }

        void Add_E(string v, string w, int c){
            matrix[NameToIndex[v]][NameToIndex[w]] = c;
        }

        void Del_V(string v){
            int index = NameToIndex[v];
            matrix.erase(matrix.begin() + index);
            isVisitedTop.erase(isVisitedTop.begin() + index);
            IndexToName.erase(IndexToName.begin() + index);
            NameToIndex.erase(v);
            for(int i = 0; i < matrix.size(); ++i)
                matrix.erase(matrix.begin() + index);
            for (auto& x : NameToIndex)
                if (x.second > index)
                    --x.second;
        }

        auto Del_E(string v, string w){
            matrix[NameToIndex[v]][NameToIndex[w]] = 0;
        }

        auto Edit_V(string v, bool mark){
            isVisitedTop[NameToIndex[v]] = mark;
        }

        auto Edit_E(string v, string w, int c){
            matrix[NameToIndex[v]][NameToIndex[w]] = c;
        }

        auto print(){
            cout << endl;
            for(int i = 0; i < matrix.size(); ++i){
                if(!matrix[i].empty()) {
                    for (int j = 0; j < matrix[i].size(); ++j) {
                        cout << matrix[i][j] << ' ';
                    }
                    cout << endl;
                }

            }
        }

        auto GetWeight(string first, string second) {
            long long i = NameToIndex[first], j = NameToIndex[second];
            if (i < matrix.size() && j < matrix.size())
                return matrix[i][j];
            else throw runtime_error("l");
        }

        bool IsVisited(string node) {
            return isVisitedTop[NameToIndex[node]];
        }


        vector<string> IndexToName;
    private:

        vector<bool> isVisitedTop;
        vector<vector<int>> matrix;
        map<string, int> NameToIndex;


    };


void dfs(Graph g, string name, vector<string>& res, long long int k, string way = "") {
    if (g.IsVisited(name) || k < 0)
        return;
    way += ' ' + name;
    if (k == 0) {
        res.push_back(way);
        return;
    }
    g.Edit_V(name, true);
    for (long long index = g.First(name); index != -1; index = g.Next(name, index)) {
        auto v = g.Vertex(name, index);
        dfs(g, v, res, k - g.GetWeight(name, v), way);
    }
    g.Edit_V(name, false);
}

vector<string> get_ways(Graph g, long long int k) {
    vector<string> res;
    for (auto& x : g.IndexToName) {
        string way = "";
        dfs(g, x, res, k, way);
    }
    return res;
}

int main(){
    int size;
    cin >> size;
    Graph G(size);
    set<int> visited;
    int cCount, n;
    cin >> cCount >> n;
    for(int i = 0; i < cCount; ++i){
        string first_v, second_v;
        int weight;
        cin >> first_v >> second_v >> weight;
        G.Add_E(first_v, second_v, weight);
    }
    G.print();
    cout << endl;
    vector<string> ways = get_ways(G, n);
    for(int i = 0; i < ways.size(); ++i)
        cout << ways[i] << endl;

    return 0;
}