//bellman - ford算法擅长解决有边数限制的最短路问题
//时间复杂度 O(nm)
//其中n为点数，m为边数
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, M = 10010;

int n, m, k;

int dist[N]; // 每个点到起点的距离
int backup[N];//迭代k次，需要备份数组，来避免串联情况
struct Edge
{
    int a, b, w;//a-b边 边权w
}edges[M];

int bellman_ford()
{
    //初始化距离
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    //最多经过k条边,迭代k次, 最多经过n条边，迭代n次
    for (int i = 0; i < k; i ++ )
    {
        memcpy(backup, dist, sizeof dist);//backup 存储的是dist上一次迭代的数据。

        for (int j = 0; j < m; j ++ ) //for a, b, w 所有边。遍历所有边
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b],  backup[a] + w);//每一次更新都是在上一次迭代的基础上进行的，这样才能防止串联情况。
            //理论上，如果没有k次迭代这个约束，就不用备份了。
            //但，如果没有k次迭代这个约束，也就不会用bellman_ford()了，😀
        }
    }
    return dist[n];
}

int main()
{
    scanf("%d%d%d", &n, &m, &k);

    for (int i = 0; i < m; i ++ )
    {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edges[i] = {a, b, w};
    }

    int t = bellman_ford();
    //为什么要大于 0x3f3f3f3f / 2 , 因为存在负权边，且无穷大不是真的无穷大，而且只能走k条边，>0x3f3f3f3f - 5e6 都是相当于达到不了
    if (t > 0x3f3f3f3f / 2) puts("impossible");//放在这里判断会过滤掉 最短路==-1的情况
    else printf("%d\n", t);

    return 0;
}