Language: C++

// {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x),end(x)
#define RALL(x) rbegin(x),rend(x)
#define REP(i,n) for ( int i=0; i<int(n); i++ )
#define REP1(i,a,b) for ( int i=(a); i<=int(b); i++ )
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int,int> PII;
typedef vector<int> VI;

namespace { namespace unolight {
// Read Input
template<class T> void _R( T &x ) { cin>>x; }
void _R( int &x ) { scanf("%d",&x); }
void _R( int64_t &x ) { scanf("%" PRId64,&x); }
void _R( double &x ) { scanf("%lf",&x); }
void _R( char &x ) { scanf(" %c",&x); }
void _R( char *x ) { scanf("%s",x); }
void R() {}
template<class T, class... U> void R( T& head, U&... tail ) { _R(head); R(tail...); }
// Write Output
template<class T> void _W( const T &x ) { cout<<x; }
void _W( const int &x ) { printf("%d",x); }
void _W( const int64_t &x ) { printf("%" PRId64,x); }
void _W( const double &x ) { printf("%.16f\n",x); }
void _W( const char &x ) { putchar(x); }
void _W( const char *x ) { printf("%s",x); }
template<class T> void _W( const vector<T> &x ) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W( const T& head, const U&... tail ) { _W(head); putchar(sizeof...(tail)?' ':'\n'); W(tail...); }

#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {
    sort(begin(v),end(v),f);
    v.resize(unique(begin(v),end(v))-begin(v));
}
// }}}

struct edge {
    int from,to,cost;
};
const LL INF=1e18;

void main() {
    int n,m,p;
    R(n,m,p);
    vector<edge> es(m);
    REP(i,m) {
        int a,b,c;
        R(a,b,c);
        --a; --b;
        es[i]={a,b,p-c};
    }
    vector<LL> dist(n,INF);
    dist[0]=0;
    REP(k,n) {
        bool update=false;
        REP(i,m) {
            int from=es[i].from,to=es[i].to,cost=es[i].cost;
            if ( dist[to]>dist[from]+cost ) {
                dist[to]=dist[from]+cost;
                if ( to==n-1 ) update=true;
            }    
        }
        if ( k+1==n && update ) {
            W(-1);
            return;
        } 
    }
    dist[n-1]*=-1;
    chmax(dist[n-1],0);
    W(dist[n-1]);
}

}} // {{{ main
int main() { unolight::main(); return 0; }
// }}}

Compiler output:
a.cc: In function 'void {anonymous}::unolight::main()':
a.cc:87:10: error: no matching function for call to 'chmax(__gnu_cxx::__alloc_traits<std::allocator<long int>, long int>::value_type&, int)'
   87 |     chmax(dist[n-1],0);
      |     ~~~~~^~~~~~~~~~~~~
a.cc:45:31: note: candidate: 'template<class T> bool {anonymous}::unolight::chmax(T&, const T&)'
   45 | template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
      |                               ^~~~~
a.cc:45:31: note:   template argument deduction/substitution failed:
a.cc:87:10: note:   deduced conflicting types for parameter 'const T' ('long int' and 'int')
   87 |     chmax(dist[n-1],0);
      |     ~~~~~^~~~~~~~~~~~~