inf = float('inf')



n, m = list(map(int, input().split()))



e = []

for _ in range(m):

    s, t, c = list(map(int, input().split()))

    s -= 1

    t -= 1

    c *= -1

    e.append((s, t, c))



dist = [inf] * n

dist[0] = 0

ans = None

for cnt in range(n * 2):

    for s, t, c in e:

        if dist[s] != inf and dist[t] > dist[s] + c:

            dist[t] = dist[s] + c

            update = True

    if cnt == n - 1:

        ans = -dist[n - 1]

if ans != -dist[n - 1]:

    print('inf')

else:

    print(ans)



# 「ベルマンフォード法」の pythonのコード

# (https://juppy.hatenablog.com/entry/2018/10/30/%E6%9C%80%E7%9F%AD%E7%B5%8C%E8%B7%AF%E9%96%A2%E9%80%A3_python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0)

#

# Bellman Fordは負辺があってもかまわない場合の単一始点全点間最短距離を求め，同時に負閉路の存在を検出するアルゴリズムである．

#

# これは動的計画法に基づくアルゴリズムで，k 回目の更新によって始点から k ステップ以下で進む場合の最短距離が計算される．

# もし n 回目にもまだ更新があるのならば，経路はどこかに負の閉路を含んでいるので，

# その頂点への経路には負閉路が存在するとして距離を負の無限大に設定する．

# (http://www.prefield.com/algorithm/graph/bellman_ford.html)

#

# 通常の Bellman-Ford 法における負閉路検出は、後者の負閉路に対して「負閉路あり」と判定してしまうことに注意。それを防ぐためには、

# 本来 Bellman-Ford は N-1 回のイテレーションで終わるので N 回目以降にも更新が行われたら負閉路ありとしていたところを

# N 回目以降にも頂点 N への最短路が更新されたら、「1 から N までの間に負閉路あり」

# と判定すればいい。この場合、ループは 2N 回程度回せば確実。

# (http://drken1215.hatenablog.com/entry/2019/02/16/075900)

def Bellman_Ford(s, g, inf=1 << 60):

    # https://tjkendev.github.io/procon-library/python/graph/bellman-ford.html

    N = len(g)

    dist = [inf] * N

    dist[s] = 0



    for _ in range(N):

        not_updated = True

        for v in range(N):

            for u, c in g[v]:

                if (dist[v] == inf) or (dist[v] + c >= dist[u]): continue

                dist[u] = dist[v] + c

                not_updated = False

        if not_updated: break



    else:

        # 負閉路が存在する

        ret = dist[N - 1]

        for v in range(N):

            for u, c in g[v]:

                if (dist[v] == inf) or (dist[v] + c >= dist[u]): continue

                dist[u] = dist[v] + c



        if ret == dist[N - 1]:

            return -ret

        else:

            return 'inf'



    return -dist[N - 1]





def main():

    import sys

    input = sys.stdin.readline



    sys.setrecursionlimit(10 ** 7)



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



    g = tuple(set() for _ in range(N))

    for _ in range(M):

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

        a -= 1

        b -= 1

        g[a].add((b, -c))



    ans = Bellman_Ford(s=0, g=g)

    print(ans)





if __name__ == '__main__':

    main()

inf = float("inf")
n, m = list(map(int, input().split()))
e = []
for _ in range(m):
    s, t, c = list(map(int, input().split()))
    s -= 1
    t -= 1
    c *= -1
    e.append((s, t, c))
dist = [inf] * n
dist[0] = 0
ans = None
for cnt in range(n * 2):
    for s, t, c in e:
        if dist[s] != inf and dist[t] > dist[s] + c:
            dist[t] = dist[s] + c
            update = True
    if cnt == n - 1:
        ans = -dist[n - 1]
if ans != -dist[n - 1]:
    print("inf")
else:
    print(ans)
# 「ベルマンフォード法」の pythonのコード
# (https://juppy.hatenablog.com/entry/2018/10/30/%E6%9C%80%E7%9F%AD%E7%B5%8C%E8%B7%AF%E9%96%A2%E9%80%A3_python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0)
#
# Bellman Fordは負辺があってもかまわない場合の単一始点全点間最短距離を求め，同時に負閉路の存在を検出するアルゴリズムである．
#
# これは動的計画法に基づくアルゴリズムで，k 回目の更新によって始点から k ステップ以下で進む場合の最短距離が計算される．
# もし n 回目にもまだ更新があるのならば，経路はどこかに負の閉路を含んでいるので，
# その頂点への経路には負閉路が存在するとして距離を負の無限大に設定する．
# (http://www.prefield.com/algorithm/graph/bellman_ford.html)
#
# 通常の Bellman-Ford 法における負閉路検出は、後者の負閉路に対して「負閉路あり」と判定してしまうことに注意。それを防ぐためには、
# 本来 Bellman-Ford は N-1 回のイテレーションで終わるので N 回目以降にも更新が行われたら負閉路ありとしていたところを
# N 回目以降にも頂点 N への最短路が更新されたら、「1 から N までの間に負閉路あり」
# と判定すればいい。この場合、ループは 2N 回程度回せば確実。
# (http://drken1215.hatenablog.com/entry/2019/02/16/075900)

def Bellman_Ford(s, g, inf=1 << 60):
    # https://tjkendev.github.io/procon-library/python/graph/bellman-ford.html
    N = len(g)
    dist = [inf] * N
    dist[s] = 0
    for _ in range(N):
        not_updated = True
        for v in range(N):
            for u, c in g[v]:
                if (dist[v] == inf) or (dist[v] + c >= dist[u]):
                    continue
                dist[u] = dist[v] + c
                not_updated = False
        if not_updated:
            break
    else:
        # 負閉路が存在する
        ret = dist[N - 1]
        for v in range(N):
            for u, c in g[v]:
                if (dist[v] == inf) or (dist[v] + c >= dist[u]):
                    continue
                dist[u] = dist[v] + c
        if ret == dist[N - 1]:
            return -ret
        else:
            return "inf"
    return -dist[N - 1]


def main():
    import sys

    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    N, M = list(map(int, input().split()))
    g = tuple(set() for _ in range(N))
    for _ in range(M):
        a, b, c = list(map(int, input().split()))
        a -= 1
        b -= 1
        g[a].add((b, -c))
    ans = Bellman_Ford(s=0, g=g)
    print(ans)


if __name__ == "__main__":
    main()

-inf = float("inf") -n, m = list(map(int, input().split())) -e = [] -for _ in range(m): -    s, t, c = list(map(int, input().split())) -    s -= 1 -    t -= 1 -    c *= -1 -    e.append((s, t, c)) -dist = [inf] * n -dist[0] = 0 -ans = None -for cnt in range(n * 2): -    for s, t, c in e: -        if dist[s] != inf and dist[t] > dist[s] + c: -            dist[t] = dist[s] + c -            update = True -    if cnt == n - 1: -        ans = -dist[n - 1] -if ans != -dist[n - 1]: -    print("inf") -else: +def Bellman_Ford(s, g, inf=1 << 60): +    # https://tjkendev.github.io/procon-library/python/graph/bellman-ford.html +    N = len(g) +    dist = [inf] * N +    dist[s] = 0 +    for _ in range(N): +        not_updated = True +        for v in range(N): +            for u, c in g[v]: +                if (dist[v] == inf) or (dist[v] + c >= dist[u]): +                    continue +                dist[u] = dist[v] + c +                not_updated = False +        if not_updated: +            break +    else: +        # 負閉路が存在する +        ret = dist[N - 1] +        for v in range(N): +            for u, c in g[v]: +                if (dist[v] == inf) or (dist[v] + c >= dist[u]): +                    continue +                dist[u] = dist[v] + c +        if ret == dist[N - 1]: +            return -ret +        else: +            return "inf" +    return -dist[N - 1] + + +def main(): +    import sys + +    input = sys.stdin.readline +    sys.setrecursionlimit(10**7) +    N, M = list(map(int, input().split())) +    g = tuple(set() for _ in range(N)) +    for _ in range(M): +        a, b, c = list(map(int, input().split())) +        a -= 1 +        b -= 1 +        g[a].add((b, -c)) +    ans = Bellman_Ford(s=0, g=g) -# 「ベルマンフォード法」の pythonのコード -# (https://juppy.hatenablog.com/entry/2018/10/30/%E6%9C%80%E7%9F%AD%E7%B5%8C%E8%B7%AF%E9%96%A2%E9%80%A3_python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0) -# -# Bellman Fordは負辺があってもかまわない場合の単一始点全点間最短距離を求め，同時に負閉路の存在を検出するアルゴリズムである． -# -# これは動的計画法に基づくアルゴリズムで，k 回目の更新によって始点から k ステップ以下で進む場合の最短距離が計算される． -# もし n 回目にもまだ更新があるのならば，経路はどこかに負の閉路を含んでいるので， -# その頂点への経路には負閉路が存在するとして距離を負の無限大に設定する． -# (http://www.prefield.com/algorithm/graph/bellman_ford.html) -# -# 通常の Bellman-Ford 法における負閉路検出は、後者の負閉路に対して「負閉路あり」と判定してしまうことに注意。それを防ぐためには、 -# 本来 Bellman-Ford は N-1 回のイテレーションで終わるので N 回目以降にも更新が行われたら負閉路ありとしていたところを -# N 回目以降にも頂点 N への最短路が更新されたら、「1 から N までの間に負閉路あり」 -# と判定すればいい。この場合、ループは 2N 回程度回せば確実。 -# (http://drken1215.hatenablog.com/entry/2019/02/16/075900) + + +if __name__ == "__main__": +    main()