idea :

Apply bellman ford and analyze which all nodes are included in the cycle

if any node that is included in cycle is reachable by 1 mark that node as affected or danger node.

now backtrack from nth node to 1st node (starting node) .. if any danger node or affected node lies in this path then answer is -1. else return distance from 1 to n .

/*
    Author : Bhavya Kawatra
 Institute : MAIT
      Dept : CST
     Email : bhavyakawatra6@gmail.com
 CF handle : bhavyakawatra
*/
#include <bits/stdc++.h>
using namespace std;

//input full vector
template<class T>istream& operator >> (istream &is, vector<T>& V) {for(auto &e : V)is >> e;return is;}

#define db double
#define im INT_MAX
#define ll long long
#define mod 1000000007
#define mod2 998244353
#define vi vector<int>
#define vb vector<bool>
#define vvi vector<vi>
#define vvb vector<vb>
#define vp vector<pair<int,int>>
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define T true
#define F false
#define mem(x, y) memset(x, y, sizeof(x))
#define sp(x) cout << fixed;cout << setprecision(x)
#define sz size()
#define mahadev ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define PI 3.14159265358979323846
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define full_line(s) getline(cin, s)
#define in(n) int n;cin >> n
#define in2(a, b) int a,b;cin >> a >> b
#define in3(a, b, c) int a,b,c;cin >> a >> b >> c
#define in4(a, b, c,d) int a,b,c,d;cin >> a >> b >> c>>d
#define max_heap(pq) priority_queue <int> pq
#define min_heap(pq) priority_queue <int, vector<int>, greater<int> > pq
#define asort(v) sort(v.begin(),v.end())
#define dsort(v) sort(v.rbegin(),v.rend())
#define endl "\n"
#define pn(p) cout<<p<<endl
#define pt(p) cout<<p<<" "
#define pt2(p,q) cout<<p<<" "<<q<<endl
#define pt3(p,q,r) cout<<p<<" "<<q<<" "<<r<<endl
#define pt4(p,q,r,s) cout<<p<<" "<<q<<" "<<r<<" "<<s<<endl
#define vfor(v) for (auto itr =v.begin() ; itr!=v.end(); itr++)
#define vbfor(v) for (auto itr =v.rbegin() ; itr!=v.rend(); itr++)
#define ffor(i, a, b) for (int i = a; i < b; i++)
#define bfor(i, a, b) for (int i = a - 1; i >= b; i--)
#define all(v) v.begin(),v.end()
#define Y "YES" 
#define NO "NO" 
#define int long long
#define ai array<int,2>


/*------------------------------------begin------------------------------------

*/

vector<vector<ai>> g;
vi affected,accessedFromStart;

void dfs(int r){
    affected[r]=1;
    for(auto i:g[r]){
        if(!affected[i[0]]){
            dfs(i[0]);
        }
    }
}

void dfs1(int r){
    accessedFromStart[r]=1;
    for(auto i:g[r]){
        if(!accessedFromStart[i[0]]){
            dfs1(i[0]);
        }
    }
}

void solve()
{
    // declarations..
    in2(n,m);
    vi prnt(n+5,-1);
    vi dist(n+5,-1e15);
    affected.assign(n+5,0);
    vector<array<int,3>>edg;
    g.assign(n+5,vector<ai>());
    accessedFromStart.assign(n+5,0);

    // taking input
    ffor(i,0,m){
        in3(x,y,wt);
        edg.pb({x,y,wt});
        g[x].pb({y,wt});
    }

    // bellman ford algorithm..
    dist[1]=0;
    ffor(i,0,n-1){
        for(auto e:edg){
            if(dist[e[1]]<dist[e[0]]+e[2]){
                dist[e[1]]=dist[e[0]]+e[2];
                prnt[e[1]]=e[0];
            }
        }
    }

    // checking for positive weighted cycles (bellman ford)
    ffor(i,0,n){
        for(auto e:edg){
            if(dist[e[1]]<dist[e[0]]+e[2]){
                dist[e[1]]=dist[e[0]]+e[2];
                affected[e[1]]=1;// makrking nodes which are affected by cycles
            }
        }
    }

    dfs1(1); // to check node which can be accessed from start we are doing dfs1 ..
    // this is done because Starting Node is 1 (given)

    // checking which nodes are affected by cycle and are in path starting from 1
    ffor(i,1,n+1){
        if(accessedFromStart[i] && affected[i]){
            dfs(i);// chcking affected nodes can lead to which more nodes..
        }
    }

    // checking back path from n to 1 .. whether in between any node is affected by cylce 
    int r=n;
    while(r!=-1){
        if(affected[r]){
            pn(-1);
            return;
        }
        r=prnt[r];
    }
    pn(dist[n]);

}

/*-------------------------------------end-------------------------------------*/
signed main()
{
    // mahadev;
    solve();
    return 0;
}