import sys





def input(): return sys.stdin.readline().strip()





N, M = (list)(list(map(int, input().split())))

edge = []



for _ in range(M):

    edge.append((list)(list(map(int, input().split()))))





inf = 10**15



d = [inf]*(N+1)

d[1] = 0

ans = inf

for i in range(N):

    update = False

    for a, b, c in edge:

        c = -c

        new_d = d[a]+c

        if d[a] != inf and d[b] > new_d:

            d[b] = new_d

            update = True



    if not update:

        break



neg = [False]*(N+1)

for i in range(N):

    for a, b, c in edge:

        c = -c

        new_d = d[a]+c

        if d[a] != inf and d[b] > new_d:

            d[b] = new_d

            neg[b] = True

        if neg[a]:

            neg[b] = True



if neg[-1]:

    print('inf')

else:

    print((-d[-1]))

# -*- coding: utf-8 -*-



"""

・ベルマンフォード

"""



import sys

def input(): return sys.stdin.readline().strip()

sys.setrecursionlimit(10 ** 9)



N, M = list(map(int, input().split()))



edges = [None] * M

for i in range(M):

    a, b, c = list(map(int, input().split()))

    # 0-indexed

    # コストの正負を逆転させれば最短経路問題として処理できる

    edges[i] = (a-1, b-1, -c)



def bellman_ford(N, edges, start):

    # 頂点[ある始点からの最短距離]

    # (経路自体を知りたい時はここに前の頂点も持たせる)

    verts = [float('inf')] * N

    verts[start] = 0

    # 各辺によるコストの置き換えを頂点数N-1回繰り返す

    for i in range(N-1):

        for src, dest, cost in edges:

            verts[dest] = min(verts[src] + cost, verts[dest])

    # 無限に減らせる場所がないか確認

    for src, dest, cost in edges:

        if verts[src] + cost < verts[dest]:

            verts[dest] = verts[src] + cost

            if dest == N-1:

                # 頂点Nがそれに該当していたら空リストを返却

                return []

    # 問題なければ頂点リストを返却

    return verts



verts = bellman_ford(N, edges, 0)

if not verts:

    print('inf')

else:

    # 正負を戻して出力

    print((-verts[N-1]))

import sys


def input():
    return sys.stdin.readline().strip()


N, M = (list)(list(map(int, input().split())))
edge = []
for _ in range(M):
    edge.append((list)(list(map(int, input().split()))))
inf = 10**15
d = [inf] * (N + 1)
d[1] = 0
ans = inf
for i in range(N):
    update = False
    for a, b, c in edge:
        c = -c
        new_d = d[a] + c
        if d[a] != inf and d[b] > new_d:
            d[b] = new_d
            update = True
    if not update:
        break
neg = [False] * (N + 1)
for i in range(N):
    for a, b, c in edge:
        c = -c
        new_d = d[a] + c
        if d[a] != inf and d[b] > new_d:
            d[b] = new_d
            neg[b] = True
        if neg[a]:
            neg[b] = True
if neg[-1]:
    print("inf")
else:
    print((-d[-1]))

# -*- coding: utf-8 -*-
"""
・ベルマンフォード
"""
import sys


def input():
    return sys.stdin.readline().strip()


sys.setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
edges = [None] * M
for i in range(M):
    a, b, c = list(map(int, input().split()))
    # 0-indexed
    # コストの正負を逆転させれば最短経路問題として処理できる
    edges[i] = (a - 1, b - 1, -c)


def bellman_ford(N, edges, start):
    # 頂点[ある始点からの最短距離]
    # (経路自体を知りたい時はここに前の頂点も持たせる)
    verts = [float("inf")] * N
    verts[start] = 0
    # 各辺によるコストの置き換えを頂点数N-1回繰り返す
    for i in range(N - 1):
        for src, dest, cost in edges:
            verts[dest] = min(verts[src] + cost, verts[dest])
    # 無限に減らせる場所がないか確認
    for src, dest, cost in edges:
        if verts[src] + cost < verts[dest]:
            verts[dest] = verts[src] + cost
            if dest == N - 1:
                # 頂点Nがそれに該当していたら空リストを返却
                return []
    # 問題なければ頂点リストを返却
    return verts


verts = bellman_ford(N, edges, 0)
if not verts:
    print("inf")
else:
    # 正負を戻して出力
    print((-verts[N - 1]))

+# -*- coding: utf-8 -*- +""" +・ベルマンフォード +""" -N, M = (list)(list(map(int, input().split()))) -edge = [] -for _ in range(M): -    edge.append((list)(list(map(int, input().split())))) -inf = 10**15 -d = [inf] * (N + 1) -d[1] = 0 -ans = inf -for i in range(N): -    update = False -    for a, b, c in edge: -        c = -c -        new_d = d[a] + c -        if d[a] != inf and d[b] > new_d: -            d[b] = new_d -            update = True -    if not update: -        break -neg = [False] * (N + 1) -for i in range(N): -    for a, b, c in edge: -        c = -c -        new_d = d[a] + c -        if d[a] != inf and d[b] > new_d: -            d[b] = new_d -            neg[b] = True -        if neg[a]: -            neg[b] = True -if neg[-1]: +sys.setrecursionlimit(10**9) +N, M = list(map(int, input().split())) +edges = [None] * M +for i in range(M): +    a, b, c = list(map(int, input().split())) +    # 0-indexed +    # コストの正負を逆転させれば最短経路問題として処理できる +    edges[i] = (a - 1, b - 1, -c) + + +def bellman_ford(N, edges, start): +    # 頂点[ある始点からの最短距離] +    # (経路自体を知りたい時はここに前の頂点も持たせる) +    verts = [float("inf")] * N +    verts[start] = 0 +    # 各辺によるコストの置き換えを頂点数N-1回繰り返す +    for i in range(N - 1): +        for src, dest, cost in edges: +            verts[dest] = min(verts[src] + cost, verts[dest]) +    # 無限に減らせる場所がないか確認 +    for src, dest, cost in edges: +        if verts[src] + cost < verts[dest]: +            verts[dest] = verts[src] + cost +            if dest == N - 1: +                # 頂点Nがそれに該当していたら空リストを返却 +                return [] +    # 問題なければ頂点リストを返却 +    return verts + + +verts = bellman_ford(N, edges, 0) +if not verts: -    print((-d[-1])) +    # 正負を戻して出力 +    print((-verts[N - 1]))