"""

unionFind木を使う。

根に対する距離を記録していく。

"""

import sys

sys.setrecursionlimit(2000000)

input = sys.stdin.readline

class UnionFind():

    def __init__(self,n):

        self.n=n

        self.parents = [i for i in range(n+1)]

        self.distance = [0]*(n+1)



    def find(self,x):

        if self.parents[x]==x:

            return x,0

        else:

            self.parents[x],dist2=self.find(self.parents[x])

            self.distance[x] += dist2

            return self.parents[x],self.distance[x]



    def union(self,l,r,dist):

        lRoot,lDist = self.find(l)

        rRoot,rDist = self.find(r)

        #まず、位置関係に矛盾がないかを調べる

        #lRootはlよりlDist右にいる

        #rRootはrよりrDist右にいる

        #lRoot=rRootのとき、lDist-rDist != distなら矛盾。

        if lRoot==rRoot and lDist-rDist != dist:

            print("No")

            exit()



        #より左にいる根を右にいる根にマージする

        if lDist < dist+rDist:

            #lRootがrRootよりも左の場合

            self.parents[lRoot]=rRoot

            self.distance[lRoot]=(dist+rDist)-lDist

        else:

            self.parents[rRoot]=lRoot

            self.distance[rRoot]=lDist-(dist+rDist)



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

tree = UnionFind(N)

for i in range(M):

    L,R,D = list(map(int,input().split()))

    tree.union(L,R,D)



print('Yes')
import sys

sys.setrecursionlimit(2000000)

input = sys.stdin.readline

class UnionFind():

    def __init__(self,n):

        self.n=n

        self.parents = [i for i in range(n+1)]

        #dist[x]はxとその親との間の距離を保持している

        self.dist = [0]*(n+1)

    def find(self,x):

        if self.parents[x]==x:

            return x

        else:

            a = self.parents[x]

            self.parents[x]=self.find(self.parents[x])

            self.dist[x] += self.dist[a]

            return self.parents[x]

    def unite(self,l,r,d):

        rRoot = self.find(r)

        lRoot = self.find(l)

        if rRoot == lRoot:

            if self.dist[l] - self.dist[r] != d:

                print("No")

                exit()

        else:

            #rRootとlRoot、どちらが親になるべきか決める

            newLDist = d + self.dist[r]

            if newLDist>=self.dist[l]:

                self.parents[lRoot] = rRoot

                self.dist[lRoot] = newLDist-self.dist[l]

            else:

                self.parents[rRoot] = lRoot

                self.dist[rRoot] = self.dist[l]-newLDist



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

tree = UnionFind(N)

for _ in range(M):

    l,r,d = list(map(int,input().split()))

    tree.unite(l,r,d)

print("Yes")
"""
unionFind木を使う。
根に対する距離を記録していく。
"""
import sys

sys.setrecursionlimit(2000000)
input = sys.stdin.readline


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [i for i in range(n + 1)]
        self.distance = [0] * (n + 1)

    def find(self, x):
        if self.parents[x] == x:
            return x, 0
        else:
            self.parents[x], dist2 = self.find(self.parents[x])
            self.distance[x] += dist2
            return self.parents[x], self.distance[x]

    def union(self, l, r, dist):
        lRoot, lDist = self.find(l)
        rRoot, rDist = self.find(r)
        # まず、位置関係に矛盾がないかを調べる
        # lRootはlよりlDist右にいる
        # rRootはrよりrDist右にいる
        # lRoot=rRootのとき、lDist-rDist != distなら矛盾。
        if lRoot == rRoot and lDist - rDist != dist:
            print("No")
            exit()
        # より左にいる根を右にいる根にマージする
        if lDist < dist + rDist:
            # lRootがrRootよりも左の場合
            self.parents[lRoot] = rRoot
            self.distance[lRoot] = (dist + rDist) - lDist
        else:
            self.parents[rRoot] = lRoot
            self.distance[rRoot] = lDist - (dist + rDist)


N, M = list(map(int, input().split()))
tree = UnionFind(N)
for i in range(M):
    L, R, D = list(map(int, input().split()))
    tree.union(L, R, D)
print("Yes")

import sys

sys.setrecursionlimit(2000000)
input = sys.stdin.readline


class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [i for i in range(n + 1)]
        # dist[x]はxとその親との間の距離を保持している
        self.dist = [0] * (n + 1)

    def find(self, x):
        if self.parents[x] == x:
            return x
        else:
            a = self.parents[x]
            self.parents[x] = self.find(self.parents[x])
            self.dist[x] += self.dist[a]
            return self.parents[x]

    def unite(self, l, r, d):
        rRoot = self.find(r)
        lRoot = self.find(l)
        if rRoot == lRoot:
            if self.dist[l] - self.dist[r] != d:
                print("No")
                exit()
        else:
            # rRootとlRoot、どちらが親になるべきか決める
            newLDist = d + self.dist[r]
            if newLDist >= self.dist[l]:
                self.parents[lRoot] = rRoot
                self.dist[lRoot] = newLDist - self.dist[l]
            else:
                self.parents[rRoot] = lRoot
                self.dist[rRoot] = self.dist[l] - newLDist


N, M = list(map(int, input().split()))
tree = UnionFind(N)
for _ in range(M):
    l, r, d = list(map(int, input().split()))
    tree.unite(l, r, d)
print("Yes")

-""" -unionFind木を使う。 -根に対する距離を記録していく。 -""" -        self.distance = [0] * (n + 1) +        # dist[x]はxとその親との間の距離を保持している +        self.dist = [0] * (n + 1) -            return x, 0 +            return x -            self.parents[x], dist2 = self.find(self.parents[x]) -            self.distance[x] += dist2 -            return self.parents[x], self.distance[x] +            a = self.parents[x] +            self.parents[x] = self.find(self.parents[x]) +            self.dist[x] += self.dist[a] +            return self.parents[x] -    def union(self, l, r, dist): -        lRoot, lDist = self.find(l) -        rRoot, rDist = self.find(r) -        # まず、位置関係に矛盾がないかを調べる -        # lRootはlよりlDist右にいる -        # rRootはrよりrDist右にいる -        # lRoot=rRootのとき、lDist-rDist != distなら矛盾。 -        if lRoot == rRoot and lDist - rDist != dist: -            print("No") -            exit() -        # より左にいる根を右にいる根にマージする -        if lDist < dist + rDist: -            # lRootがrRootよりも左の場合 -            self.parents[lRoot] = rRoot -            self.distance[lRoot] = (dist + rDist) - lDist +    def unite(self, l, r, d): +        rRoot = self.find(r) +        lRoot = self.find(l) +        if rRoot == lRoot: +            if self.dist[l] - self.dist[r] != d: +                print("No") +                exit() -            self.parents[rRoot] = lRoot -            self.distance[rRoot] = lDist - (dist + rDist) +            # rRootとlRoot、どちらが親になるべきか決める +            newLDist = d + self.dist[r] +            if newLDist >= self.dist[l]: +                self.parents[lRoot] = rRoot +                self.dist[lRoot] = newLDist - self.dist[l] +            else: +                self.parents[rRoot] = lRoot +                self.dist[rRoot] = self.dist[l] - newLDist -for i in range(M): -    L, R, D = list(map(int, input().split())) -    tree.union(L, R, D) +for _ in range(M): +    l, r, d = list(map(int, input().split())) +    tree.unite(l, r, d)