```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
	"strconv"
)

type Item struct {
	dist int64
	node int
}

type MinHeap []Item

func (h MinHeap) Len() int           { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i].dist < h[j].dist }
func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *MinHeap) Push(x interface{}) {
	*h = append(*h, x.(Item))
}
func (h *MinHeap) Pop() interface{} {
	old := *h
	n := len(old)
	item := old[n-1]
	*h = old[0 : n-1]
	return item
}

type Edge struct {
	to     int
	weight int
}

type KEdge struct {
	u, v int
	w    int64
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		res, _ := strconv.Atoi(scanner.Text())
		return res
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	m := readInt()

	adj := make([][]Edge, n+1)

	type RawEdge struct {
		u, v, w int
	}
	edges := make([]RawEdge, 0, m)

	for i := 0; i < m; i++ {
		u := readInt()
		v := readInt()
		w := readInt()
		adj[u] = append(adj[u], Edge{v, w})
		adj[v] = append(adj[v], Edge{u, w})
		edges = append(edges, RawEdge{u, v, w})
	}

	k := readInt()

	portals := make([]int, k)
	isPortal := make([]bool, n+1)
	for i := 0; i < k; i++ {
		portals[i] = readInt()
		isPortal[portals[i]] = true
	}

	dist := make([]int64, n+1)
	c := make([]int, n+1)
	for i := 1; i <= n; i++ {
		dist[i] = -1
	}

	pq := &MinHeap{}
	heap.Init(pq)

	for _, p := range portals {
		dist[p] = 0
		c[p] = p
		heap.Push(pq, Item{dist: 0, node: p})
	}

	for pq.Len() > 0 {
		curr := heap.Pop(pq).(Item)
		u := curr.node
		d := curr.dist

		if d > dist[u] {
			continue
		}

		for _, edge := range adj[u] {
			v := edge.to
			w := int64(edge.weight)
			if dist[v] == -1 || dist[u]+w < dist[v] {
				dist[v] = dist[u] + w
				c[v] = c[u]
				heap.Push(pq, Item{dist: dist[v], node: v})
			}
		}
	}

	kruskalEdges := make([]KEdge, 0)
	for _, edge := range edges {
		u := edge.u
		v := edge.v
		if c[u] != c[v] && c[u] != 0 && c[v] != 0 {
			w := dist[u] + int64(edge.w) + dist[v]
			kruskalEdges = append(kruskalEdges, KEdge{c[u], c[v], w})
		}
	}

	sort.Slice(kruskalEdges, func(i, j int) bool {
		return kruskalEdges[i].w < kruskalEdges[j].w
	})

	parent := make([]int, n+1)
	for i := 1; i <= n; i++ {
		parent[i] = i
	}

	var find func(int) int
	find = func(i int) int {
		if parent[i] == i {
			return i
		}
		parent[i] = find(parent[i])
		return parent[i]
	}

	mstCost := int64(0)
	edgesUsed := 0

	for _, e := range kruskalEdges {
		rootU := find(e.u)
		rootV := find(e.v)
		if rootU != rootV {
			parent[rootU] = rootV
			mstCost += e.w
			edgesUsed++
			if edgesUsed == k-1 {
				break
			}
		}
	}

	dist1 := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		dist1[i] = -1
	}

	pq1 := &MinHeap{}
	heap.Init(pq1)

	dist1[1] = 0
	heap.Push(pq1, Item{dist: 0, node: 1})

	var minDist1 int64 = -1

	for pq1.Len() > 0 {
		curr := heap.Pop(pq1).(Item)
		u := curr.node
		d := curr.dist

		if d > dist1[u] {
			continue
		}

		if isPortal[u] {
			minDist1 = d
			break
		}

		for _, edge := range adj[u] {
			v := edge.to
			w := int64(edge.weight)
			if dist1[v] == -1 || dist1[u]+w < dist1[v] {
				dist1[v] = dist1[u] + w
				heap.Push(pq1, Item{dist: dist1[v], node: v})
			}
		}
	}

	fmt.Println(mstCost + minDist1)
}
```