//
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
const int kN = 2e5 + 10;
const LL kInf = 1e18 + 2077;
const LL p = 998244353;
//=============================================================
int n, m, q;
LL a[kN], b[kN];

struct Edge {
  int v, w;
  bool operator < (const Edge sec_) const {
    return v < sec_.v;
  }
};
std::vector<Edge> edge[kN];
int du_lim;

struct Node {
  LL f;
  int v, w, tag;
  bool operator < (const Node sec_) const {
    return f < sec_.f;
  }
};
LL f[kN];
std::vector<Node> s[kN];
int nowtime, time_lim, tag[kN];
std::vector<int> upded;
//=============================================================
void rebuild() {
  upded.clear();
  for (int i = 1; i <= n; ++ i) {
    if ((int) edge[i].size() <= du_lim) continue;
    s[i].clear();
    for (auto [v, w]: edge[i]) s[i].push_back((Node) {f[v] + w, v, w, tag[v]});
  }
}
void update(int u_) {
  ++ tag[u_];
  upded.push_back(u_);
  f[u_] = kInf;

  if ((int) edge[u_].size() <= du_lim) {
    for (auto [v, w]: edge[u_]) f[u_] = std::min(f[u_], f[v] + w);
    return ;
  }
  std::nth_element(s[u_].begin(), s[u_].begin() + du_lim + 1, s[u_].end());
  for (int i = 0; i <= du_lim; ++ i) {
    int v = s[u_][i].v, tt = s[u_][i].tag; LL ff = s[u_][i].f;
    if (tt == tag[v]) f[u_] = std::min(f[u_], ff);
  }
  for (auto v: upded) {
    auto it = std::lower_bound(edge[u_].begin(), edge[u_].end(), (Edge) {v, 0});
    if (it == edge[u_].end() || it->v != v) continue;
    f[u_] = std::min(f[u_], f[v] + it->w);
  }
}
//=============================================================
int main() {
  //freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  std::cin >> n >> m >> q;
  for (int i = 1; i <= n; ++ i) std::cin >> a[i];
  for (int i = 1; i <= m; ++ i) {
    int u, v, w; std::cin >> u >> v >> w;
    edge[u].push_back((Edge) {v, w});
    edge[v].push_back((Edge) {u, w});
  }
  for (int i = 1; i <= n; ++ i) std::sort(edge[i].begin(), edge[i].end());
  for (int i = 1; i <= q; ++ i) std::cin >> b[i];

  du_lim = time_lim = sqrt(m);
  rebuild();
  for (int i = q; i; -- i) {
    if (++ nowtime == time_lim) rebuild();
    update(b[i]);
  }
  LL ans = 0;
  for (int i = 1; i <= n; ++ i) (ans += f[i] * a[i] % p) %= p;
  std::cout << ans << "\n";
  return 0;
}