#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>

using namespace std;

#define FOR(i,k,n) for(int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)

template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cerr<<*i<<" "; cerr<<endl; }
inline bool valid(int x, int y, int W, int H){ return (x >= 0 && y >= 0 && x < W && y < H); }

typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
struct Edge{
  int src, dst, cost;
  Edge(int u, int v, int c) : 
    src(u), dst(v), cost(c) {}
};
typedef vector<Edge> Node;
typedef vector<Node> Graph;
struct State{
  int room, S, cost;
  State(int r, int S, int c) :
    room(r), S(S), cost(c) {}
  bool operator < (const State& s) const {
    if(cost != s.cost) return cost > s.cost;
    if(room != s.room) return room > s.room;
    return S > s.S;
  }
};

int main(){
  int N, M, L, K;
  while(cin >> N >> M >> L >> K && N){
    Graph G(N);
    REP(i, M){
      int u, v, c;
      cin >> u >> v >> c;
      u--; v--;
      G[u].push_back(Edge(u, v, c));
      G[v].push_back(Edge(v, u, c));
    }
    int Start, Goal;
    cin >> Start >> Goal;
    Start--; Goal--;
    vector<int> B(N, -1);
    REP(i, L){
      int t; cin >> t;
      B[t - 1] = i;
    }
    vector<int> dist[50][1 << 7];
    priority_queue<State> que;
    State init(Start, (B[Start] != -1) ? 1 << B[Start] : 0, 0);
    que.push(init);
    while(!que.empty()){
      State s = que.top(); que.pop();
      if(dist[s.room][s.S].size() >= K) continue;
      dist[s.room][s.S].push_back(s.cost);
      FORIT(e, G[s.room]){
        State next = s;
        next.room = e->dst;
        next.cost += e->cost;
        if(B[next.room] != -1){
          next.S |= 1 << B[next.room];
        }
        if(dist[next.room][next.S].size() < K){
          que.push(next);
        }
      }
    }
    if(dist[Goal][(1 << L) - 1].size() == K){
      cout << dist[Goal][(1 << L) - 1].back() << endl;
    }else{
      cout << "NA" << endl;
    }
  }
  return 0;
}