#!/usr/bin/env python3
import heapq
import math


def get_dists(graph):
    """Computes distances to all other vertices and visitation order."""
    n = len(graph)
    order = []
    pq = [(0, 0)]
    dist = [math.inf for _ in range(n)]
    dist[0] = 0

    while pq:
        du, u = heapq.heappop(pq)
        if dist[u] != du:
            continue

        order.append(u)
        for v, w in graph[u]:
            if du + w < dist[v]:
                dist[v] = du + w
                heapq.heappush(pq, (dist[v], v))

    return dist, order


def solve(n, edges, log):
    graph = [[] for _ in range(n)]
    for u, v, w in edges:
        graph[u].append((v, w))

    dist, order = get_dists(graph)
    if log[-1] > dist[-1]:
        return 0

    ways = [0 for _ in range(n)]
    ways[0] = 1
    log_ptr = 0
    prev = [-1 for _ in range(n)]

    for u in order:
        if not ways[u]:
            continue

        while log_ptr < len(log) and log[log_ptr] <= dist[u]:
            log_ptr += 1

        for v, w in graph[u]:
            if dist[u] + w == dist[v] and (
                log_ptr >= len(log) or dist[v] <= log[log_ptr]
            ):
                ways[v] = min(2, ways[v] + ways[u])
                prev[v] = u

    if ways[-1] == 0:
        return 0
    elif ways[-1] == 2:
        return 1
    else:
        path = []
        u = n - 1
        while u > 0:
            path.append(u)
            u = prev[u]
            assert u != -1
        path.append(0)
        return list(reversed(path))


def main():
    n, m, d = map(int, input().split())
    edges = []
    for _ in range(m):
        u, v, w = map(int, input().split())
        edges.append((u - 1, v - 1, w))

    log = [int(input()) for _ in range(d)]

    ans = solve(n, edges, log)
    if isinstance(ans, int):
        print(ans)
    else:
        print(len(ans))
        for x in ans:
            print(x + 1)


if __name__ == "__main__":
    main()