#include <map>

#include <set>

#include <cmath>

#include <ctime>

#include <stack>

#include <queue>

#include <cstdio>

#include <cctype>

#include <bitset>

#include <string>

#include <vector>

#include <cstring>

#include <iostream>

#include <algorithm>

#include <functional>

#define fuck(x) cout<<"["<<x<<"]";

#define FIN freopen("input.txt","r",stdin);

#define FOUT freopen("output.txt","w+",stdout);

#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

typedef long long LL;

typedef pair<int, int> PII;

const int maxn =  + ;

const int INF = 0x3f3f3f3f;

int s, t, k;

bool vis[maxn];

int dist[maxn];

struct Node {

    int v, c;

    Node (int _v = , int _c = ) : v(_v), c(_c) {}

    bool operator < (const Node &rhs) const {

        return c + dist[v] > rhs.c + dist[rhs.v];

    }

};

struct Edge {

    int v, cost;

    Edge (int _v = , int _cost = ) : v(_v), cost(_cost) {}

};

vector<Edge>E[maxn], revE[maxn];

void Dijkstra(int n, int s) {

    memset(vis, false, sizeof(vis));

    for (int i = ; i <= n; i++) dist[i] = INF;

    priority_queue<Node>que;

    dist[s] = ;

    que.push(Node(s, ));

    while (!que.empty()) {

        Node tep = que.top(); que.pop();

        int u = tep.v;

        if (vis[u]) continue;

        vis[u] = true;

        for (int i = ; i < (int)E[u].size(); i++) {

            int v = E[u][i].v;

            int cost = E[u][i].cost;

            if (!vis[v] && dist[v] > dist[u] + cost) {

                dist[v] = dist[u] + cost;

                que.push(Node(v, dist[v]));

            }

        }

    }

}

int astar(int s) {

    priority_queue<Node> que;

    que.push(Node(s, )); k--;

    while (!que.empty()) {

        Node pre = que.top(); que.pop();

        int u = pre.v;

        if (u == t) {

            if (k) k--;

            else return pre.c;

        }

        for (int i = ; i < (int)revE[u].size(); i++) {

            int v = revE[u][i].v;

            int c = revE[u][i].cost;

            que.push(Node(v, pre.c + c));

        }

    }

    return -;

}

void addedge(int u, int v, int w) {

    revE[u].push_back(Edge(v, w));

    E[v].push_back(Edge(u, w));

}

int main() {

#ifndef ONLINE_JUDGE

    FIN

    #endif

    int n, m, u, v, w;

    while (scanf("%d%d", &n, &m) != EOF) {

        for (int i = ; i <= n; i++) {

            E[i].clear();

            revE[i].clear();

        }

        for (int i = ; i < m; i++) {

            scanf("%d%d%d", &u, &v, &w);

            addedge(u, v, w);

        }

        scanf("%d%d%d", &s, &t, &k);

        Dijkstra(n, t);

        if (dist[s] == INF) {

            puts("-1");

            continue;

        }

        if (s == t) k++;

        printf("%d\n", astar(s));

    }

    return ;

}