#include <bits/stdc++.h>
#define rep(a,n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
using ll = long long;
typedef pair<ll,ll> P;
typedef pair<P,ll> PP;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e18;

ll n,m,p;

template< typename T >
struct Edge {//辺の構造体を作る
    ll from,to;
    T cost;
    ll idx;//辺の番号

    Edge() = default;//omajinai

    //初期化
    Edge(ll from,ll to,T cost = 1, ll idx =-1):from(from),to(to),cost(cost),idx(idx){}
    
    /*
    operator ll() const{ return to; }
    */
};

template< typename T=ll >
struct Graph {
    vector< vector< Edge< T > > > g;
    ll es;//辺のidに相当

    Graph() = default;

    explicit Graph(ll n):g(n),es(0){}//explicitにより値渡しでコンストラクタを呼ばれないようにする

    size_t size() const{
        return g.size();//size関数を使った時にはグラフの大きさを返すようにする
    }

    void add_directed_edge(ll from,ll to, T cost=1){//有向辺
        g[from].emplace_back(from,to,cost,es++);
    }

    void add_edge(ll from,ll to,T cost = 1){//無向辺
        g[from].emplace_back(from,to,cost,es);
        g[to].emplace_back(to,from,cost,es++);//esを追加してから++してる
    }

    void read(ll M,ll padding = -1,bool weighted = false,bool directed=false){
        for(ll i=0;i<M;i++){
            ll a,b;
            cin >> a >> b;
            a += padding;
            b += padding;
            T c = T(1);//costなしなら1
            if(weighted)cin>>c;
            if(directed)add_directed_edge(a,b,c);
            else add_edge(a,b,c);
        }
    }
};

template< typename T = ll >
using Edges = vector< Edge< T > >;


/*重みつきグラフと始点を引数にとり、始点から全頂点間の最短コストを求める
到達出来ない頂点には型の最大値を格納する*/
/*このライブラリを用いることで重みつきグラフの構築さえ行えば
ダイクストラを勝手に行ってくれてとても便利!*/

template< typename T >
vector< T > dijkstra(const Graph< T > &g, ll s){
    const auto INF = numeric_limits< T >::max();
    vector< T > dist(g.size(),INF);//始点からの距離を格納

    using Pi = pair< T , ll >;
    priority_queue<Pi,vector<Pi>,greater<> >que;
    dist[s]=0;
    que.emplace(dist[s],s);
    while(!que.empty()){
        T cost;
        ll idx;
        tie(cost,idx) = que.top();
        que.pop();
        if(dist[idx] < cost)continue;//すでによりコストの低い経路があった場合
        for(auto &e:g.g[idx]){
            auto next_cost = cost + e.cost;
            if(dist[e.to] <= next_cost)continue;
            dist[e.to] = next_cost;
            que.emplace(dist[e.to],e.to);
        }
    }
    return dist;
}

template< typename T >
vector< T > bellman_ford(const Edges< T > &edges, ll V, ll s) {
  const auto INF = numeric_limits< T >::max();
  vector< T > dist(V, INF);
  dist[s] = 0;
  for(ll i = 0; i < V - 1; i++) {
    for(auto &e : edges) {
      if(dist[e.from] == INF) continue;
      dist[e.to] = min(dist[e.to], dist[e.from] + e.cost);
    }
  }
  for(auto &e : edges) {
    if(dist[e.from] == INF) continue;
    if(dist[e.from] + e.cost < dist[e.to]) return vector< T >();
  }
  return dist;
}


int main(){
    //input
    cin >> n >> m >> p;
    vector<ll>a(m),b(m),c(m);
    rep(i,m){
        cin>>a[i]>>b[i]>>c[i];
        a[i]--;b[i]--;
    }

    //頂点Nまで到達できるかの判定
    Graph<ll> g(n);
    rep(i,m){
        g.add_directed_edge(b[i],a[i],c[i]);
    }
    auto from_n = dijkstra(g,n-1);
    vector<bool> pos(n,false);
    rep(i,n){
        if(from_n[i]==numeric_limits<ll>::max()){
            pos[i]=true;
        }
    }

    Graph<ll>g2(n);
    rep(i,m){
        g2.add_directed_edge(a[i],b[i],c[i]);
    }
    auto from_0 = dijkstra(g2,0);
    rep(i,n){
        if(from_0[i]==numeric_limits<ll>::max()){
            pos[i]=true;
        }
    }

    //ベルマンフォード
    Edges<ll> E;
    rep(i,m){
        if(pos[a[i]])continue;
        if(pos[b[i]])continue;
        ll cost = p-c[i];
        if(a[i]==b[i]){
            if(cost<0){
                cout << -1 << endl;
                return 0;
            }
            else{
                continue;
            }
        }
        E.push_back({a[i],b[i],cost});
    }

    auto dist = bellman_ford(E,n,0);
    if(dist.size()==0){
        cout << -1 << endl;
        return 0;
    }
    if(dist[n-1]>=0){
        cout << 0 << endl;
    }
    else{
        cout << -dist[n-1] << endl;
    }


    return 0;
}

Measured memory_bytes: 4472