/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author edamat
 */

#include <bits/stdc++.h>

using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(int i = int(a), i##_len = (b); i < i##_len; ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _repr(i, n) repri(i, n, 0)
/* loop in [n,m] step -1 */
#define repri(i, a, b) for(int i = int(a), i##_len = (b); i >= i##_len; --i)
/* loop in [n,0] step -1 or [n,m] step -1 */
#define repr(...) _overload3(__VA_ARGS__, repri, _repr, )(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << ": " << (x) << '\n'
#define pb push_back
#define eb emplace_back
#define endl '\n'
typedef long long lint;
//#define int lint
const int INF = numeric_limits<int>::max();
//int MOD = (int) 1e9 + 7;
//const double EPS = 1e-9;
const lint LINF = (lint) (1LL << 62) - 1;
typedef vector<int> vint;
typedef pair<int, int> pint;

struct IoSetup {
    IoSetup() {
        cin.tie(nullptr);
        ios::sync_with_stdio(false);
//        cout << fixed << setprecision(20);
//        cerr << fixed << setprecision(20);
    }
} iosetup;

using std::to_string;

auto to_string(std::string s) -> std::string {
    return '"' + s + '"';
}

auto to_string(char c) -> std::string {
    return "'" + std::string{c} + "'";
}

auto to_string(const char *s) -> std::string {
    return to_string((std::string) s);
}

auto to_string(bool b) -> std::string {
    return (b?"true":"false");
}

template<typename T, typename U>
auto to_string(std::pair<T, U> p) -> std::string {
    return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template<size_t N>
auto to_string(std::bitset<N> bs) -> std::string {
    std::string res{};
    for(size_t i = 0; i < N; i++)
        res.insert(res.begin(), bs.test(i)?'1':'0');
    return res;
}

template<typename T>
auto to_string(T v) -> std::string {
    bool flg = false;
    std::string res = "[";
    for(auto const &x : v){
        if(flg) res += ", ";
        else flg = true;
        res += to_string(x);
    }
    res += "]";
    return res;
}

#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define SZ(x) ((int)(x).size())

/* range macro. usage: for(int i:range(n)) */
class range {
private:
    struct I {
        int x;
        
        int operator*() { return x; }
        
        bool operator!=(I &lhs) { return x < lhs.x; }
        
        void operator++() { ++x; }
    };
    
    I i, n;

public:
    range(int n) : i({0}), n({n}) {}
    
    range(int i, int n) : i({i}), n({n}) {}
    
    I &begin() { return i; }
    
    I &end() { return n; }
};

/* keep a max,min */
template<class T>
bool chmax(T &a, const T &b) {
    if(a < b){
        a = b;
        return 1;
    }
    return 0;
}

template<class T>
bool chmin(T &a, const T &b) {
    if(a > b){
        a = b;
        return 1;
    }
    return 0;
}

/* input,output operator for pair and vector */
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
    os << p.first << " " << p.second;
    return os;
}

template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
    is >> p.first >> p.second;
    return is;
}

template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    for(int i = 0; i < (int) v.size(); i++){
        os << v[i] << (i + 1 != v.size()?" ":"");
    }
    return os;
}

template<typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
    for(int i = 0; i < (int) v.size(); i++){
        os << v[i] << (i + 1 != v.size()?"\n":"");
    }
    return os;
}

template<typename T>
istream &operator>>(istream &is, vector<T> &v) {
    for(T &in : v) is >> in;
    return is;
}

template<typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
    os << "{";
    for(auto x = mp.begin(); x != mp.end(); ++x){
        os << x->first << ":" << x->second
           << (x != prev(mp.end())?", ":"");
    }
    os << "}";
    return os;
}

/* initialize vector. usage: auto v = male_v<int>(N,0); */
template<typename T>
vector<T> make_v(size_t a) {
    return vector<T>(a);
}

template<typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}

/* fill vector. usage: fill_v(v,0); */
template<typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
    t = v;
}

template<typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
    for(auto &e : t) fill_v(e, v);
}

/* sum */
template<typename T>
lint sum(vector<T> &v) {
    lint ret = 0;
    for(auto x : v){
        ret += x;
    }
    return ret;
}

double sum(vector<double> &v) {
    double ret = 0;
    for(auto x : v){
        ret += x;
    }
    return ret;
}

template<typename T>
auto sum(const T &a) {
    return a;
}

template<typename T, typename... A>
auto sum(const T &first, const A &... rest) {
    return sum(first) + sum(rest...);
}

/* mod */
lint intpow(lint a, lint n, lint mod) {
    lint res = 1;
    while(n > 0){
        if(n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

template<typename T>
T intpow(T a, lint n) {
    T res = 1;
    while(n > 0){
        if(n & 1) res = res * a;
        a = a * a;
        n >>= 1;
    }
    return res;
}

long long modinv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while(b){
        long long t = a / b;
        a -= t * b;
        swap(a, b);
        u -= t * v;
        swap(u, v);
    }
    u %= m;
    if(u < 0) u += m;
    return u;
}

/* print */
template<typename T>
void print(const T &first) {
    cout << first << endl;
}

template<typename T, typename... A>
void print(const T &first, const A &... rest) {
    cout << first << " ";
    print(rest...);
}

template<typename... A>
void print(const A &... rest) {
    print(rest...);
}
struct RandomNumberGenerator {
    mt19937 mt;
    
    RandomNumberGenerator() : mt(chrono::steady_clock::now().time_since_epoch().count()) {}
    
    int operator()(int a, int b) { // [a, b)
        uniform_int_distribution<int> dist(a, b - 1);
        return dist(mt);
    }
    
    int operator()(int b) { // [0, b)
        return (*this)(0, b);
    }
};


/* Graph template */
template <typename T>
struct edge {
    int src, to;
    T cost;

    edge(int to, T cost) : src(-1), to(to), cost(cost) {}

    edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}

    edge &operator=(const int &x) {
        to = x;
        return *this;
    }
    
    edge reverse(){
        return edge(to,src,cost);
    }

    operator int() const { return to; }

    bool operator<(const edge &another) const { return cost < another.cost; };
};

/* input,output operator for edge */
template <typename T>
ostream &operator<<(ostream &os, const edge<T> &e) {
    os << e.src << "->" << e.to << ":" << e.cost << ",";
    return os;
}

template <typename T>
istream &operator>>(istream &is, edge<T> &e) {
    is >> e.src >> e.to >> e.cost;
    return is;
}

template <typename T>
using Edges = vector<edge<T>>;
template <typename T>
using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T>
using Matrix = vector<vector<T>>;

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

template<typename T>
vector<T> bellman_ford(Edges<T> &edges, int N, int s, int g) {
    const auto INF = numeric_limits<T>::max();
    vector<T> dist(N, INF);
    vector<bool> negative(N, false);
    dist[s] = 0;
    for(int i = 0; i < N - 1; i++){
        for(auto &e : edges){
            if(dist[e.src] == INF) continue;
            dist[e.to] = min(dist[e.to], dist[e.src] + e.cost);
        }
    }
    for(auto &e : edges){
        if(dist[e.src] == INF) continue;
        if(dist[e.src] + e.cost < dist[e.to]) negative[e.to] = true;
    }
    for(int i = 0; i < N; i++){
        for(auto &e : edges){
            if(negative[e.src]) negative[e.to] = true;
        }
    }
    if(negative[g]){
        return vector<T>();
    }
    return dist;
}

template<typename T>
vector<T> shortest_path_faster_algorithm(WeightedGraph<T> &g, int s) {
    const auto INF = numeric_limits<T>::max();
    vector<T> dist(g.size(), INF);
    vector<int> pending(g.size(), 0), times(g.size(), 0);
    vector<bool> negative(g.size(), false);
    queue<int> que;
    
    que.emplace(s);
    pending[s] = true;
    ++times[s];
    dist[s] = 0;
    
    while(!que.empty()){
        int p = que.front();
        que.pop();
        pending[p] = false;
        for(auto &e : g[p]){
            T next_cost = dist[p] + e.cost;
            if(next_cost >= dist[e.to]) continue;
            dist[e.to] = next_cost;
            if(!pending[e.to]){
                if(++times[e.to] >= g.size()) return vector<T>();
                pending[e.to] = true;
                que.emplace(e.to);
            }
        }
    }
    return dist;
}


template<typename T>
vector<bool> bfs(WeightedGraph<T> g, int s) {
    vector<bool> visited(g.size(), false);
    visited[s] = true;
    queue<int> q;
    q.push(s);
    while(!q.empty()){
        int v = q.front();
        q.pop();
        for(auto &e:g[v]){
            if(visited[e.to]) continue;
            visited[e.to] = true;
            q.emplace(e.to);
        }
    }
    return visited;
}

class ECoinsRespawn {
public:
    static constexpr int kStressIterations = 0;
    
    static void generateTest(int cnt, std::ostream &test) {
        RandomNumberGenerator rng;
    }
    
    void solve(std::istream &cin, std::ostream &cout) {
        int N, M, P;
        cin >> N >> M >> P;
//        Edges<int> G;
//        rep(i,M){
//            int A,B,C;
//            cin >> A >> B >> C;
//            G.push_back(edge<int>(A-1,B-1,-C+P));
//        }
//        auto v = bellman_ford(G,N,0,N-1);
//        if(v.empty()){
//            cout << -1 << endl;
//        }else{
//            cout << max(-v[N-1],0) << endl;
//        }
        WeightedGraph<int> G(N), revG(N);
        rep(i, M){
            int A, B, C;
            cin >> A >> B >> C;
            G[A - 1].eb(edge<int>(A - 1, B - 1, -C + P));
            revG[B - 1].eb(edge<int>(B - 1, A - 1, -C + P));
        }
        vector<bool> sv = bfs(G, 0);
        vector<bool> gv = bfs(revG, N - 1);
//        cout << sv << endl;
//        cout << gv << endl;
        WeightedGraph<int> ansG(N);
        for(auto &v:G){
            for(auto &e:v){
                if(sv[e.src] && gv[e.to]){
                    ansG[e.src].eb(e);
                }
            }
        }
        auto v = shortest_path_faster_algorithm(ansG, 0);
        if(v.empty()){
            cout << -1 << endl;
        } else {
            cout << max(-v[N - 1], 0) << endl;
        }
    }
};


signed main() {
	ECoinsRespawn solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 768