// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<vector>

#include<queue>

#include<algorithm>

using namespace std;

struct node

{

	int to,dis;

	node(){}

	node(int x,int y):to(x),dis(y){}

};

#define INF 1000000000

int n,m,f[100005],b[100005];

vector<node> a[100005];

void spfa(int x)

{

	queue<int> p;

	p.push(x);

	b[x]=1;

	f[x]=0;

	while (!p.empty())

	{

		int v=p.front();

		p.pop();

		for (int i=0;i<a[v].size();i++)

		{

			if (f[a[v][i].to]==INF)

			{

				f[a[v][i].to]=f[v]+a[v][i].dis;

				b[a[v][i].to]=1;

				p.push(a[v][i].to);

			}

			else if (f[a[v][i].to]!=f[v]+a[v][i].dis)

			{

				cout<<"No";

				exit(0);

			}

		}

	}

}

int main()

{

	cin>>n>>m;

	for (int i=1;i<=n;i++)

	{

		f[i]=INF;

	}

	int x,y,z;

	for (int i=1;i<=m;i++)

	{

		scanf("%d %d %d",&x,&y,&z);

		a[x].push_back(node(y,z));

		a[y].push_back(node(x,-z));

	} 

	for (int i=1;i<=n;i++)

	{

		if (b[i]==0)

		{

			spfa(i);

		}

	}

	cout<<"Yes";

} 

// Faster C++ solution for the same problem (measured speedup: 3.5620558487481664x):
#define _CRT_SECURE_NO_WARNINGS

#pragma GCC optimize(2)

#pragma GCC optimize(3)

#pragma GCC optimize("Ofast")

#pragma GCC optimize("inline")

#pragma GCC optimize("-fgcse")

#pragma GCC optimize("-fgcse-lm")

#pragma GCC optimize("-fipa-sra")

#pragma GCC optimize("-ftree-pre")

#pragma GCC optimize("-ftree-vrp")

#pragma GCC optimize("-fpeephole2")

#pragma GCC optimize("-ffast-math")

#pragma GCC optimize("-fsched-spec")

#pragma GCC optimize("unroll-loops")

#pragma GCC optimize("-falign-jumps")

#pragma GCC optimize("-falign-loops")

#pragma GCC optimize("-falign-labels")

#pragma GCC optimize("-fdevirtualize")

#pragma GCC optimize("-fcaller-saves")

#pragma GCC optimize("-fcrossjumping")

#pragma GCC optimize("-fthread-jumps")

#pragma GCC optimize("-funroll-loops")

#pragma GCC optimize("-fwhole-program")

#pragma GCC optimize("-freorder-blocks")

#pragma GCC optimize("-fschedule-insns")

#pragma GCC optimize("inline-functions")

#pragma GCC optimize("-ftree-tail-merge")

#pragma GCC optimize("-fschedule-insns2")

#pragma GCC optimize("-fstrict-aliasing")

#pragma GCC optimize("-fstrict-overflow")

#pragma GCC optimize("-falign-functions")

#pragma GCC optimize("-fcse-skip-blocks")

#pragma GCC optimize("-fcse-follow-jumps")

#pragma GCC optimize("-fsched-interblock")

#pragma GCC optimize("-fpartial-inlining")

#pragma GCC optimize("no-stack-protector")

#pragma GCC optimize("-freorder-functions")

#pragma GCC optimize("-findirect-inlining")

#pragma GCC optimize("-fhoist-adjacent-loads")

#pragma GCC optimize("-frerun-cse-after-loop")

#pragma GCC optimize("inline-small-functions")

#pragma GCC optimize("-finline-small-functions")

#pragma GCC optimize("-ftree-switch-conversion")

#pragma GCC optimize("-foptimize-sibling-calls")

#pragma GCC optimize("-fexpensive-optimizations")

#pragma GCC optimize("-funsafe-loop-optimizations")

#pragma GCC optimize("inline-functions-called-once")

#pragma GCC optimize("-fdelete-null-pointer-checks")

#include <cstdio>

#include <iostream>

#include <algorithm>

#include <cstring>

#include <queue>

#include <cmath>

using namespace std;



int N,M,cnt;

int head[100050];

long long dis[100050];

bool vis[100050],inq[100050];

struct edge{

    int u,v,w,next;

}t[400050];

inline void add(int u,int v,int w){

    t[++cnt].u=u;

	t[cnt].v=v;

    t[cnt].w=w;

    t[cnt].next=head[u];

    head[u]=cnt;

}

queue<int>q;

inline bool spfa(int start){

    

    q.push(start);

    inq[start]=true;

    dis[start]=0;

    

    while(!q.empty()){

        int u=q.front();

        	q.pop();

        inq[u]=false;

    	

		for(int i=head[u];i;i=t[i].next){

            int v=t[i].v;

            	if(dis[v]==12345678987654321){

                	dis[v]=dis[u]+t[i].w;

                		vis[v]=true;

                	if(!inq[v])

                   		q.push(v);

            	}

            	else 

				if(dis[v]!=dis[u]+t[i].w)

                	return false;

        }

    }

    return true;

}



int main(){

	scanf("%d%d",&N,&M);

    for(int i=1;i<=M;i++){

    	int u,v,w;

        scanf("%d%d%d",&u,&v,&w);

        add(u,v,w),add(v,u,-w);

    }

    for(int i=1;i<=N;i++)

		dis[i]=12345678987654321;

    for(int i=1;i<=N;i++){

        if(!vis[i]){

            vis[i]=true;

            	bool flag=spfa(i);

            	if(!flag){

                	printf("No\n");

                		return 0;

            	}

        }

    }

    printf("Yes\n");

    return 0;

}