import scala.collection.mutable

object Main extends App {
  import scala.io.StdIn._


  solve
  def solve: Unit = {
    val Array(n, m, l, k) = readLine.trim.split(' ').map(_.toInt)
    if (n == 0 && m == 0 && l == 0 && k == 0) return
    val rooms = Array.tabulate(n){_ ⇒ Nil:List[Edge]}
    for (_ ← 0 until m){
      val Array(u, v, c) = readLine.trim.split(' ').map(_.toInt)
      rooms(u - 1) ::= Edge(v - 1, c)
      rooms(v - 1) ::= Edge(u - 1, c)
    }
    val Array(start, goal) = readLine.trim.split(' ').map(_.toInt - 1)
    val doragosoNumber = Array.tabulate(n){_ ⇒ -1}
    for (d ← 0 until l){
      doragosoNumber(readInt - 1) = d
    }
    val minCost = Array.tabulate(n){_ ⇒ Array.tabulate(1 << l){_ ⇒ new KthMemo(k)}}
    val queue = mutable.PriorityQueue()(Ordering.by[(Flag, Int, Int), Int](_._3).reverse)
    val firstFlag = new Flag().let(f ⇒ if (doragosoNumber(start) != -1) f.added(doragosoNumber(start)) else f)
    minCost(start)(firstFlag.toInt).setIfAnyGreater(0)
    queue.enqueue((firstFlag, start, 0))
    while (queue.nonEmpty){
      val (flag, current, time) = queue.dequeue()
      if (minCost(current)(flag.toInt).contains(time)) {
        for (Edge(next, cost) ← rooms(current)) {
          if (doragosoNumber(next) != -1 && minCost(next)(flag.added(doragosoNumber(next)).toInt).setIfAnyGreater(time + cost)) {
            queue.enqueue((flag.added(doragosoNumber(next)), next, time + cost))
          }else if (doragosoNumber(next) == -1 && minCost(next)(flag.toInt).setIfAnyGreater(time + cost)) {
            queue.enqueue((flag, next, time + cost))
          }
        }
      }
    }
    val result = minCost(goal)((1 << l) - 1).allValues
    if (result.size < k) println("NA")
    else println(result(k - 1))
    solve
  }
  case class Edge(to: Int, cost: Int)
  class KthMemo(private[this] val size: Int) {
    private[this] val memo: Array[Int] = Array.tabulate(size){_ ⇒ Int.MaxValue}
    private[this] var pushed: Int = 0
    def setIfAnyGreater(value: Int): Boolean = {
      if (pushed < size) {
        memo(pushed) = value
        pushed += 1
        true
      }else {
        Some(memo.indices.maxBy(memo)).filter(i ⇒ memo(i)>value).also(_.foreach(memo(_)=value)).isDefined
      }
    }
    def contains(value: Int): Boolean = memo.contains(value)
    def allValues = (0 until pushed).map(memo).sorted
  }
  class Flag(private[this] val flag: Int = 0) {
    def added(index: Int): Flag = new Flag(flag | (1 << index))
    def isAdded(index: Int): Boolean = if (index >= 0) (flag & (1 << index)) != 0 else false
    def toInt = flag
  }
  implicit class Scope[T](val value: T) extends AnyVal{
    @inline
    def also(@inline func: T ⇒ Unit): T = {
      func(value)
      value
    }
    @inline
    def let[A](func: T ⇒ A): A = func(value)
  }
}
