#include <fstream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;

ifstream fin ("trafic.in");
ofstream fout ("trafic.out");

vector <pair <int, int> > l[160];

int n,m,i,x,y,minim,sol,c[160][160],f[160][160],t[160],d[160],dd[160],C,g,st,dr,T,j,OK;


queue <int> q;

void bfs(){
    int fr,sc;
    q.push(1);
    while (q.size()) {
        x=q.front();
        for (int i=0;i<l[x].size();i++) {
            fr=l[x][i].first,sc=l[x][i].second;
            if (d[x]+sc<d[fr]){
                d[fr]=d[x]+sc;
                q.push(fr);
            }
        }
        q.pop();
    }
}
void bfs1(){
    int fr,sc;
    q.push(n);
    while (q.size()) {
        x=q.front();
        for (int i=0;i<l[x].size();i++) {
            fr=l[x][i].first,sc=l[x][i].second;
            if (dd[x]+sc<dd[fr]){
                dd[fr]=dd[x]+sc;
                q.push(fr);
            }
        }
        q.pop();
    }
}

bool bfs2 () {

    int p,u;

    t[1]=-1;
    p=u=1;
    q.push(1);
    while (q.size()) {
        x=q.front();
        for (int i=0;i<l[x].size();i++) {
            y=l[x][i].first;
            if (t[y]==0 && c[x][y]>f[x][y]) {
                q.push(y);
                t[y]=x;
            }
        }
        q.pop();
    }

    return (t[n]==0?0:1);
}

int main () {

    fin>>n>>m>>g;
    while (m--) {
        fin >> x >> y >> C;
        C*=10;
        l[x].push_back(make_pair(y,C));
    }
    for (i=2;i<=n;i++)
        d[i]=dd[i]=50000000;
    bfs();
    bfs1();

    st=0;dr=d[n];
    while (st<=dr) {
        T=(st+dr)/2;
        sol=0;
        for (i=1;i<=n;i++) {
            for (j=0;j<l[i].size();j++){
                if (T>=d[i]&&T>=dd[l[i][j].first]&&2*T>=d[i]+dd[l[i][j].first]+l[i][j].second)
                    c[i][l[i][j].first]=1;
                else
                    c[i][l[i][j].first]=100000;
                f[i][l[i][j].first]=0;
            }
        }
        while (bfs2()){
            for (i=0;i<l[n].size();i++) {
                x=l[n][i].first;
                if (t[x]!=0 && c[x][n]>f[x][n]){
                    minim=c[x][n]-f[x][n];
                    while (t[x]!=-1){
                        minim=min(minim,c[t[x]][x]-f[t[x]][x]);
                        x=t[x];
                    }
                    x=l[n][i].first;
                    f[x][n]+=minim;
                    f[n][x]-=minim;
                    while (t[x]!=-1){
                        f[t[x]][x]+=minim;
                        f[x][t[x]]-=minim;
                        x=t[x];
                    }
                    sol+=minim;
                }
            }
            memset(t,0,sizeof(t));
        }
        if (sol<=g) {
            dr=T-1;
            OK=1;
        }
        else
            st=T+1;
    }

    if (OK){
        double b=st/10;
        fout<<b<<"\n";
    }else
        fout<<"-1\n";


    return 0;
}