#include <stdio.h>
#include <iostream>
#include <cstdio>
#include <algorithm> 
#include <stdio.h>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <list>
#include <utility>
#include <set>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <numeric>
#include <bitset>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <random>

using namespace std;

static const double EPS = 1e-9;
template<class T> bool INRANGE(T x, T a, T b) { return a <= x && x <= b; }
template<class T> void amin(T &a, T v) { if (a > v) a = v; }
template<class T> void amax(T &a, T v) { if (a < v) a = v; }
int ROUND(double x) { return (int)(x + 0.5); }
bool ISINT(double x) { return fabs(ROUND(x) - x) <= EPS; }
bool ISEQUAL(double x, double y) { return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y))); }
double SQSUM(double x, double y) { return x * x + y * y; }
#define PI  (acos(-1))
#define ARRAY_NUM(a) (sizeof(a)/sizeof(a[0])) 
#define NG (-1)
#define BIG ((int)1e9+10)
#define BIGLL ((ll)4e18)
#define SZ(a) ((int)(a).size())
#define SQ(a) ((a)*(a))
typedef unsigned long long ull;
typedef long long ll;

// modint: mod 計算を int を扱うように扱える構造体
template<int MOD>
struct ModInt {
	long long val;
	constexpr ModInt(long long v = 0) noexcept : val(v % MOD) {
		if (val < 0) v += MOD;
	}
	constexpr int getmod() { return MOD; }
	constexpr ModInt operator - () const noexcept {
		return val ? MOD - val : 0;
	}
	constexpr ModInt operator + (const ModInt& r) const noexcept { return ModInt(*this) += r; }
	constexpr ModInt operator - (const ModInt& r) const noexcept { return ModInt(*this) -= r; }
	constexpr ModInt operator * (const ModInt& r) const noexcept { return ModInt(*this) *= r; }
	constexpr ModInt operator / (const ModInt& r) const noexcept { return ModInt(*this) /= r; }
	constexpr ModInt& operator += (const ModInt& r) noexcept {
		val += r.val;
		if (val >= MOD) val -= MOD;
		return *this;
	}
	constexpr ModInt& operator -= (const ModInt& r) noexcept {
		val -= r.val;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr ModInt& operator *= (const ModInt& r) noexcept {
		val = val * r.val % MOD;
		return *this;
	}
	constexpr ModInt& operator /= (const ModInt& r) noexcept {
		long long a = r.val, b = MOD, u = 1, v = 0;
		while (b) {
			long long t = a / b;
			a -= t * b; swap(a, b);
			u -= t * v; swap(u, v);
		}
		val = val * u % MOD;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr bool operator == (const ModInt& r) const noexcept {
		return this->val == r.val;
	}
	constexpr bool operator != (const ModInt& r) const noexcept {
		return this->val != r.val;
	}

	friend ostream& operator << (ostream &os, const ModInt<MOD>& x) noexcept {
		return os << x.val;
	}
	friend istream& operator >> (istream &is, ModInt<MOD>& x) noexcept {
		return is >> x.val;
	}
	friend constexpr ModInt<MOD> modpow(const ModInt<MOD> &a, long long n) noexcept {
		if (n == 0) return 1;
		auto t = modpow(a, n / 2);
		t = t * t;
		if (n & 1) t = t * a;
		return t;
	}
};

// 二項係数ライブラリ
template<class T> struct BiCoef
{
	constexpr BiCoef() {}
	constexpr BiCoef(int n) noexcept : mFact(n, 1), mInv(n, 1), mFInv(n, 1)
	{
		Init(n);
	}

	constexpr void Init(int n) noexcept
	{
		mFact.assign(n, 1), mInv.assign(n, 1), mFInv.assign(n, 1);
		int MOD = mFact[0].getmod();
		for (int i = 2; i < n; i++) {
			mFact[i] = mFact[i - 1] * i;
			mInv[i] = -mInv[MOD%i] * (MOD / i);
			mFInv[i] = mFInv[i - 1] * mInv[i];
		}
	}

	constexpr T Fact(int n) const noexcept {
		if (n < 0) return 0;
		return mFact[n];
	}

	constexpr T Comb(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[k] * mFInv[n - k];
	}

	constexpr T Perm(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[k] * mFInv[n - k];
	}

	// 重複組み合わせ。3種類の玉
	constexpr T Homo(int n, int r) const {
		if (n < 0 || r < 0) return 0;
		return r == 0 ? 1 : Comb(n + r - 1, r);
	}

	constexpr T inv(int n) const noexcept {
		if (n < 0) return 0;
		return mInv[n];
	}

	constexpr T finv(int n) const noexcept {
		if (n < 0) return 0;
		return mFInv[n];
	}

	vector<T> mFact;
	vector<T> mInv;
	vector<T> mFInv;
};

const int MOD = 1000000007;
using mint = ModInt<MOD>;
BiCoef<mint> bc;

// 注：要素数カウント。あらかじめソートしておくこと。
// 全部 0～Nの値を返す。
// 同じ意味のも多数あるので、混乱しないこと。

// ＞X の要素数を求める。
template <class T>
int numGT(const vector <T>& v, T x)
{
	const int N = SZ(v);
	return N - (upper_bound(v.begin(), v.end(), x) - v.begin());
}

// ≧X の要素数を求める。
template <class T>
int numGTE(const vector <T>& v, T x)
{
	const int N = SZ(v);
	return N - (lower_bound(v.begin(), v.end(), x) - v.begin());
}

// ＜X の要素数を求める
// ≧Xの最初のindexを求める。全ての要素がX未満のときNを返す。
// 例えば{3,5,7,8,8,10}でx=8なら3を返す
template <class T>
int numLT(const vector <T>& v, T x)
{
	return lower_bound(v.begin(), v.end(), x) - v.begin();
}

// ≦X の要素数を求める。
// ＞Xの最初のindexを求める。全ての要素がX以下のときNを返す。
// 例えば{3,5,7,8,8,10}でx=8なら5を返す
template <class T>
int numLTE(const vector <T>& v, T x)
{
	return upper_bound(v.begin(), v.end(), x) - v.begin();
}

// ある数字がどの半区間 [v[i], v[i+1)に入るかを求めるときは、1を引くこと。すごく汎用的！
//    x＜3 ... -1（最初の要素未満）
// 3≦x＜5 ...  0
// 5≦x＜7 ...  1
// 7≦x＜8 ...  2
template <class T>
int indexRange(const vector <T>& v, T x)
{
	return upper_bound(v.begin(), v.end(), x) - v.begin() - 1;
}

const int MAX_V = 3000;
const int MAX_E = 6000;

struct BELL_EDGE
{
	int from;
	int to;
	ll cost;
};

BELL_EDGE es[MAX_E];

ll d[MAX_V]; // 最短距離
int V, E; // Vは頂点数、Eは辺数

 // s番目の頂点から各頂点への最短距離を求める
bool Bellman(int s)
{
	for (int i = 0; i < V; i++)
	{
		d[i] = BIGLL;
	}
	d[s] = 0;


	for (int turn=0; turn <= MAX_V; turn++)
	{
		for (int i = 0; i < E; i++)
		{
			BELL_EDGE e = es[i];
			if (d[e.from] != BIGLL && d[e.to] > d[e.from] + e.cost)
			{
				d[e.to] = d[e.from] + e.cost;
			}
		}
	}

	ll dS = d[V-1];

	for (int turn = 0; turn <= MAX_V; turn++)
	{
		for (int i = 0; i < E; i++)
		{
			BELL_EDGE e = es[i];
			if (d[e.from] != BIGLL && d[e.to] > d[e.from] + e.cost)
			{
				d[e.to] = d[e.from] + e.cost;
			}
		}
	}

	// BEGIN CUT HERE
//	cerr << " dS=" << dS << " d[V-1]=" << d[V-1] << endl;
	// END CUT HERE


	return dS == d[V - 1];
}


int main()
{
	ll N, M, P;
	cin >> N >> M >> P;

	V = N;
	E = M;

	for (int i = 0; i < M; ++i)
	{
		int a;
		int b;
		ll c;
		cin >> a >> b >> c;
		a--;
		b--;
		c -= P;
		es[i].from = a;
		es[i].to = b;
		es[i].cost = -c;
	}

	bool update = Bellman(0);

	ll ret = max(0LL, -d[N - 1]);
	if (!update)
	{
		ret = NG;
	}

	cout << ret << endl;

	return 0;
}


Measured memory_bytes: 384