#include <bits/stdc++.h>
using namespace std;
#define int long long
#define stoi stoll
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
#define ALL(c) begin(c),end(c)
#define RALL(c) rbegin(c),rend(c)
#define ITR(i,b,e) for(auto i=(b);i!=(e);++i)
#define FORE(x,c) for(auto &&x:c)
#define REPF(i,a,n) for(int i=a,i##len=(int)(n);i<i##len;++i)
#define REP(i,n) REPF(i,0,n)
#define REPR(i,n) for(int i=(int)(n);i>=0;--i)
#define SZ(c) ((int)c.size())
#define CONTAIN(c,x) (c.find(x)!=end(c))
#define INSEG(l,x,r) ((l)<=(x)&&(x)<(r))
#define dump(...)
#define pb push_back
#define _ 0
const signed INF_=1001001001; const long long INF=1001001001001001001LL;
const int DX[9]={0,1,0,-1,1,1,-1,-1,0},DY[9]={-1,0,1,0,-1,1,1,-1,0};
template<class T> ostream& operator<<(ostream &os,const vector<T> &v) {
    ITR(i,begin(v),end(v))os<<*i<<(i==end(v)-1?"":" ");return os;}
template<class T> istream& operator>>(istream &is,vector<T> &v) {
    ITR(i,begin(v),end(v)) is>>*i;return is;}
template<class T,class U> istream& operator>>(istream &is, pair<T,U> &p) {
    is>>p.first>>p.second;return is;}
template<class T, class U> bool chmax(T &a,const U &b){return a<b?a=b,1:0;}
template<class T, class U> bool chmin(T &a,const U &b){return a>b?a=b,1:0;}
template <class T> void PSUM(T& c) {partial_sum(begin(c), end(c), begin(c));}
template<class T> using heap=priority_queue<T,vector<T>,greater<T>>;
struct before_main_function {
    before_main_function() {
        cin.tie(0); ios::sync_with_stdio(false);
        cout << setprecision(15) << fixed;
        #define endl "\n"
    }
} before_main_function;
//------------------8<------------------------------------8<--------------------

signed main() {
    while (1) {
        int N, M, cap;
        cin >> N >> M >> cap;
        if (N == 0 && M == 0 && cap == 0) break;

        cap *= 10;
        int S, T;

        map<string, int> node;
        map<int, string> inv_node;
        int idx = 0;
        auto regi = [&](string name) {
            if (CONTAIN(node, name)) return;
            node[name] = idx;
            inv_node[idx] = name;
            idx++;
        };

        vector<vector<int>> edge(N);
        vector<int> gas(M);
        {
            string src, dest;
            cin >> src >> dest;
            regi(src);
            regi(dest);
            S = node[src];
            T = node[dest];
        
            REP(i, N) {
                string a, b;
                int d;
                cin >> a >> b >> d;
                regi(a); regi(b);
                edge[i] = {node[a], node[b], d};
            }
            REP(i, M) {
                string s;
                cin >> s;
                regi(s);
                gas[i] = node[s];
            }
        }

        int V = SZ(node);

        vector<vector<pii>> g(V);
        FORE(e, edge) {
            int a = e[0], b = e[1], d = e[2];
            g[a].push_back({b, d});
            g[b].push_back({a, d});
        }
        vector<bool> has_gas(V, false);
        FORE(v, gas) {
            has_gas[v] = true;
        }

        vector<vector<int>> dist(2001, vector<int>(V, INF));
        dist[cap][S] = 0;
        heap<pair<int, pii>> hp;
        hp.push({0, {cap, S}});
        while (!hp.empty()) {
            int c = hp.top().second.first;
            int v = hp.top().second.second; hp.pop();
            FORE(e, g[v]) {
                int w = e.first;
                int cost = e.second;
                if (c < cost) continue;
                if (has_gas[w]) {
                    if (chmin(dist[cap][w], dist[c][v] + cost)) {
                        hp.push({dist[cap][w], {cap, w}});
                    }
                } else {
                    if (chmin(dist[c - cost][w], dist[c][v] + cost)) {
                        hp.push({dist[c - cost][w], {c - cost, w}});
                    }
                }
            }
        }
        int ans = INF;
        REP(i, 2001) chmin(ans, dist[i][T]);
        if (ans == INF) cout << -1 << endl;
        else cout << ans << endl;
    }
    return (0^_^0);
}


