#include <algorithm>
#include <cassert>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>

using namespace std;

int main() {
    int n, m, d;
    cin >> n >> m >> d;

    vector<vector<pair<int, int64_t>>> graph(n);
    for (int i = 0; i < m; ++i) {
        int u, v;
        int64_t w;
        cin >> u >> v >> w;
        --u; --v;

        graph[u].emplace_back(v, w);
    }

    vector<int64_t> logs(d);
    for (auto& x : logs)
        cin >> x;

    sort(begin(logs), end(logs));

    // first, run dijkstra's to build the shortest path dag
    using state = pair<int64_t, int>;
    priority_queue<state, vector<state>, greater<state>> pq;
    pq.emplace(0LL, 0);

    constexpr int64_t INF = 1e18;
    vector<int64_t> dist(n, INF);
    dist[0] = 0;

    while (!pq.empty()) {
        auto [cur_dist, u] = pq.top();
        pq.pop();

        if (dist[u] != cur_dist) {
            continue;
        }

        for (auto [v, w] : graph[u]) {
            if (cur_dist + w < dist[v]) {
                dist[v] = cur_dist + w;
                pq.emplace(dist[v], v);
            }
        }
    }

    vector<int> city_order(n);
    iota(begin(city_order), end(city_order), 0);
    sort(begin(city_order), end(city_order), [&](int u, int v) {
        return dist[u] < dist[v];
    });

    // Process the cities in order of distance.
    constexpr int UNVISITED = -1;
    constexpr int SINGLE = 1;
    constexpr int MULTI = 2;

    vector<int> dp(n, UNVISITED);
    vector<int> before(n, UNVISITED);
    dp[0] = SINGLE;
    for (int u : city_order) {
        // unreachable
        if (dp[u] == -1) {
            continue;
        }

        for (auto [v, w] : graph[u]) {
            // Ensure this edge is in the shortest path DAG
            if (dist[u] + w != dist[v]) {
                continue;
            }

            // can go from u to v if we do not skip over any stops
            auto it = upper_bound(begin(logs), end(logs), dist[u]);
            if (it == end(logs) || *it <= dist[u] || *it >= dist[v]) {
                if (dp[v] == UNVISITED) {
                    dp[v] = dp[u];
                    before[v] = u;
                } else {
                    dp[v] = MULTI;
                }
            }
        }
    }

    // Corner case: can still fail if we have logs beyond the shortest path length
    if (dp.back() == UNVISITED || dist.back() < logs.back()) {
        cout << "0\n";
    } else if (dp.back() == MULTI) {
        cout << "1\n";
    } else {
        vector<int> res = {n - 1};
        while (res.back() != 0) {
            int u = res.back();
            assert(dp[u] == SINGLE);
            res.push_back(before[u]);
        }

        reverse(begin(res), end(res));
        cout << res.size() << '\n';
        for (int i = 0; i < res.size(); ++i) {
            cout << res[i] + 1 << "\n";
        }
    }

    return 0;
}