#include <bits/stdc++.h>
#define int long long
#define ll long long
using ull = unsigned long long;
using namespace std;
const int INF = 1ll << 50;
const int MOD = 1e9 + 7;
#define dump(x)                             \
    if (dbg) {                              \
        cerr << #x << " = " << (x) << endl; \
    }
#define overload4(_1, _2, _3, _4, name, ...) name
#define FOR1(n) for (ll i = 0; i < (n); ++i)
#define FOR2(i, n) for (ll i = 0; i < (n); ++i)
#define FOR3(i, a, b) for (ll i = (a); i < (b); ++i)
#define FOR4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define FOR(...) overload4(__VA_ARGS__, FOR4, FOR3, FOR2, FOR1)(__VA_ARGS__)
#define FORR(i, a, b) for (int i = (a); i <= (b); ++i)
#define bit(n, k) ((n >> k) & 1) /*nのk bit目*/
template <class T>
bool chmin(T& a, const T& b) {
    if (a > b) {
        a = b;
        return 1;
    } else
        return 0;
}
template <class T>
bool chmax(T& a, const T& b) {
    if (a < b) {
        a = b;
        return 1;
    } else
        return 0;
}
void Yes(bool flag = true) {
    if (flag)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
}
void No(bool flag = true) {
    Yes(!flag);
}
void YES(bool flag = true) {
    if (flag)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
void NO(bool flag = true) {
    YES(!flag);
}
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define SZ(x) ((int)(x).size())
//#define P pair<int, int>
//#define V vector<int>
//#define S set<int>
#define itn int
bool dbg = false;

int N, M, P;
template <typename T>
struct BellmanFord {
    static constexpr T INF = numeric_limits<T>::max();

    struct edge {
        int u, v;
        T w;
        edge() {}
        edge(int u, int v, T w) : u(u), v(v), w(w) {}
    };

    int n;
    vector<vector<int>> G;
    vector<int> used, reach;
    BellmanFord(int n) : n(n), G(n), used(n, 0), reach(n, 1) {}

    vector<edge> es;
    void add_edge(int u, int v, T c) {
        es.emplace_back(u, v, c);
        G[u].emplace_back(v);
    }

    vector<T> build(int from, int& neg_loop) {
        vector<T> ds(n, INF);
        ds[from] = 0;
        for (int j = 0; j < n; j++) {
            bool update = 0;
            for (auto e : es) {
                if (!reach[e.u] || !reach[e.v] || ds[e.u] == INF)
                    continue;
                if (ds[e.v] > ds[e.u] + e.w) {
                    ds[e.v] = ds[e.u] + e.w;
                    update = 1;
                }
            }
            if (!update)
                break;
            if (j == n - 1) {
                neg_loop = 1;
                return ds;
            }
        }
        neg_loop = 0;
        return ds;
    }

    void dfs(int v) {
        if (used[v])
            return;
        used[v] = 1;
        for (int u : G[v])
            dfs(u);
    }

    T shortest_path(int from, int to, int& neg_loop) {
        for (int i = 0; i < n; i++) {
            fill(used.begin(), used.end(), 0);
            dfs(i);
            reach[i] = used[to];
        }
        return build(from, neg_loop)[to];
    }
};
template <typename T>
constexpr T BellmanFord<T>::INF;

void solve() {
    BellmanFord<itn> bel(N);
    FOR(M) {
        int a, b, c;
        cin >> a >> b >> c;
        a--;
        b--;
        c -= P;
        bel.add_edge(a, b, -c);
    }
    int neg_loop;
    int ans = bel.shortest_path(0, N - 1, neg_loop);
    if (neg_loop) {
        cout << -1 << endl;
    } else {
        cout << max(-ans, 0ll) << endl;
    }
}

signed main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cin >> N >> M >> P;

    solve();
    return 0;
}


Measured memory_bytes: 768