#define _GLIBCXX_DEBUG
#include<cmath>
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
vector<int> arr;
//stack<int> st;
queue<int> qu;
queue<pair<int,int> > qu2;
priority_queue<int> pq;
#define rep(i,n) for(int i=0; i<(int)(n); i++)
#define rep2(i,n) for(int i=1; i<=(int)(n); i++)
typedef set<int> set_t;
typedef set<string> set_g;
typedef complex<double> xy_t;
static const int NIL = -1;
static const int INF = 1001001001;

/*int P[10010];
void init(int n){
    for(int i=0;i<n;++i)P[i]=i;
}
int root(int a) {
    if(P[a]==a)return a;
    return (P[a]=root(P[a]));
}
bool is_same_set(int a,int b){
    return root(a) == root(b);//代表元を求める
}
void unite(int a,int b){
    P[root(a)]=root(b);
}//対set,グラフ？
//セグメント木？？
*/

double dot_product(xy_t a, xy_t b) { return (conj(a)*b).real(); }//内積
double cross_product(xy_t a, xy_t b) { return (conj(a)*b).imag(); }//外積
xy_t projection(xy_t p, xy_t b) { return b*dot_product(p,b)/norm(b); }//投影
//対図形

#define mod 1000000007
/*ll f[2001];
//int n,k とかしておく

ll pw(ll x, ll y){//euclidの互除法より
    ll a= 1;
    while(y){
        if(y&1){//奇数なら
            a = a*x%mod;
        }
        x = x*x%mod;
        y /= 2;
    }
    return a;
}

ll modinv(ll x){//逆元を求める
    return pw(x, mod - 2 );
}

ll comb(int n,int r){
    if(n<r){
        return 0;
    }
    return f[n] * modinv(f[r])%mod*modinv(f[n-r])%mod;
}//対combination//ただしfは用意してね
*/

struct BIT{
    vector<int> dat;
    int sz;
    BIT(int n){
        for(sz=1;sz<n;sz *= 2);
        dat.resize(++sz);
    }
    int q(int n){
        int ret = 0;
        for(int i=n;i>0;i-=i&-i)ret +=dat[i];//和の計算　iから最後の１のbit(i&-i 多分＆はビット積)を減算
        for(int i=n;i<sz;i+=i&-i) dat[i]++;//値の加算　iから最後mの１のbitを加算
        return ret;
    }
};


vector<int> to[2505];
vector<int> rto[2505];
bool reachablefrom1[2505];
bool reachableton[2505];
bool ok[2505];

void dfs(int v){
    if(reachablefrom1[v]) return;//無限繰り返しを防ぐ
    reachablefrom1[v]=true;
    for(int u : to[v]){
        dfs(u);
    }
} 
void rdfs(int v){
    if(reachableton[v]) return;//無限繰り返しを防ぐ
    reachableton[v]=true;
    for(int u : rto[v]){
        rdfs(u);
    }
} 

int main(){
    int n, m, p;
    cin >> n>> m >> p;
    vector<tuple<int,int,int> > edges;
    rep(i,m){
        int a, b, c;
        cin >> a>> b>>c;
        --a;--b;
        c-=p;
        c=-c;
        edges.emplace_back(a,b,c);
        to[a].push_back(b);
        rto[b].push_back(a);
    }
    dfs(0);
    rdfs(n-1);
    rep(i,n) ok[i]=reachablefrom1[i]&reachableton[i];
    {// bellman-ford
        vector<int> d(n,INF);//dの初期化
        d[0]=0;
        bool upd=true;
        int step=0;
        while(upd){
            upd=false;
            rep(i,m){
                int a, b, c;
                tie(a,b,c)=edges[i];
                if(!ok[a]) continue;
                if(!ok[b]) continue;
                int newD =d[a]+c;
                if(newD<d[b]){
                    upd=true;
                    d[b]=newD;
                }
            }
            step++;
            if(step>n){
                puts("-1");
                return 0;
            }
        }
        int ans = -d[n-1];
        ans = max(ans,0);
        cout<<ans<<endl;
    }
    return 0;
}

Measured memory_bytes: 2432