stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<queue>

using namespace std;

inline void read(int&ans)

{

	ans=0;

	register char ch=getchar();

	while(ch<'0' or ch>'9')ch=getchar();

	while(ch>='0' and ch<='9')ans=ans*10+(ch^48),ch=getchar();

}

int fa[100010],n,m,dis[100010];

int find(int x)

{

	if(fa[x]!=x){

		int a=fa[x];fa[x]=find(fa[x]),dis[x]+=dis[a];	

	}

	return fa[x];

}

int main()

{

	read(n),read(m);

	for(int i=1;i<=n;i++)fa[i]=i;

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

	{

		int l,r,d;

		read(l);read(r);read(d);

		int ll=find(l),rr=find(r);

		if(ll==rr and dis[l]-dis[r]!=d)

		{

			cout<<"No";return 0;

		}

		else if(ll!=rr)

		{

			fa[ll]=rr;

			dis[ll]=dis[r]+d-dis[l];

		}

	}

	cout<<"Yes";

}

// Faster C++ solution for the same problem (measured speedup: 5.297228658596181x):
// luogu-judger-enable-o2

// SeptEtavioxy

#include<cstdio>

#include<cctype>

#include<cstring>

#include<algorithm>

#include<cmath>

#define re register

#define ll long long

#define il inline

#define rep(i,s,t) for(re int i=(s);i<=(t);i++)

#define rev_rep(i,s,t) for(re int i=(s);i>=(t);i--)

#define each(i,u) for(int i=head[u];i;i=bow[i].nxt)

#define pt(ch) putchar(ch)

#define pti(x) printf("%d",x)

#define ptll(x) printf("%lld",x)

#define file(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)

using namespace std;

// c_ints

il int ci(){

	re char ch;int f=1;

	while(!isdigit(ch=getchar()))f= ch=='-'?-1:1 ;

	re int x= ch^'0';

	while(isdigit(ch=getchar()))x=(x*10)+(ch^'0');

	return f*x;

}

enum{N=100024};

int fa[N],dis[N];

void fd(int x){

	if( fa[x]==x ) return ;

	fd(fa[x]);

	dis[x]+= dis[fa[x]];

	fa[x]= fa[fa[x]];

}

int main(){

	int n=ci(), m=ci();

	rep(i,1,n) fa[i]= i;

	while( m-- ){

		int l=ci(), r=ci(), d=ci();

		fd(l), fd(r);

		if( fa[l]==fa[r] ){

			if( dis[r]-dis[l]!=d ){

				puts("No");

				return 0;

			}

		}

		else{

			int fl=fa[l], fr=fa[r];

			int x= dis[l]+d-dis[r];

//			printf("%d %d\n",fl,fr);

//			if( x<0 ){

//				puts("No");

//				return 0;

//			}

			dis[fr]= x;

			fa[fr]= fl;

		}

//		printf("fa :");rep(i,1,n) printf("%d ",fa[i]); pt('\n');

//		printf("dis:");rep(i,1,n) printf("%d ",dis[i]); pt('\n');

	}

	puts("Yes");

	return 0;

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

#include <cstdio>

#include <algorithm>

#define N 400005

#define inf 0x7fffffff

using namespace std;



struct E {int next, to, dis;} e[N];

int n, m, num, flag, cnt;

int h[N], a[N], pos[N], obj[N];

bool vis[N];



int read()

{

	int x = 0; char c = getchar();

	while(c < '0' || c > '9') c = getchar();

	while(c >= '0' && c <= '9') {x = x * 10 + c - '0'; c = getchar();}

	return x;

}



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

{

	e[++num].next = h[u];

	e[num].to = v;

	e[num].dis = w;

	h[u] = num;

}



void dfs(int x)

{

	if(flag) return;

	vis[x] = 1;

	for(int i = h[x]; i != 0; i = e[i].next)

	{

		int t = pos[x] + e[i].dis;

		if(pos[e[i].to] == inf) pos[e[i].to] = t, dfs(e[i].to);

		else if(t != pos[e[i].to]) {flag = 1; return;}

	}

}



int main()

{

	cin >> n >> m;

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

	{

		int a = read(), b = read(), c = read();

		add(a, b, c), add(b, a, -c);

		pos[a] = pos[b] = inf;

		obj[++cnt] = a, obj[++cnt] = b;

	}

	sort(obj + 1, obj + 1 + cnt);

	cnt = unique(obj + 1, obj + 1 + cnt) - obj - 1;

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

		if(!vis[obj[i]])

		{

			flag = 0;

			pos[obj[i]] = 0;

			dfs(obj[i]);

			if(flag) {cout << "No"; return 0;}

		}

	cout << "Yes";

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.360672844583246x):
// luogu-judger-enable-o2

// SeptEtavioxy

#include<cstdio>

#include<cctype>

#include<cstring>

#include<algorithm>

#include<cmath>

#define re register

#define ll long long

#define il inline

#define rep(i,s,t) for(re int i=(s);i<=(t);i++)

#define rev_rep(i,s,t) for(re int i=(s);i>=(t);i--)

#define each(i,u) for(int i=head[u];i;i=bow[i].nxt)

#define pt(ch) putchar(ch)

#define pti(x) printf("%d",x)

#define ptll(x) printf("%lld",x)

#define file(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)

using namespace std;

// c_ints

il int ci(){

	re char ch;int f=1;

	while(!isdigit(ch=getchar()))f= ch=='-'?-1:1 ;

	re int x= ch^'0';

	while(isdigit(ch=getchar()))x=(x*10)+(ch^'0');

	return f*x;

}

enum{N=100024};

int fa[N],dis[N];

void fd(int x){

	if( fa[x]==x ) return ;

	fd(fa[x]);

	dis[x]+= dis[fa[x]];

	fa[x]= fa[fa[x]];

}

int main(){

	int n=ci(), m=ci();

	rep(i,1,n) fa[i]= i;

	while( m-- ){

		int l=ci(), r=ci(), d=ci();

		fd(l), fd(r);

		if( fa[l]==fa[r] ){

			if( dis[r]-dis[l]!=d ){

				puts("No");

				return 0;

			}

		}

		else{

			int fl=fa[l], fr=fa[r];

			int x= dis[l]+d-dis[r];

//			printf("%d %d\n",fl,fr);

//			if( x<0 ){

//				puts("No");

//				return 0;

//			}

			dis[fr]= x;

			fa[fr]= fl;

		}

//		printf("fa :");rep(i,1,n) printf("%d ",fa[i]); pt('\n');

//		printf("dis:");rep(i,1,n) printf("%d ",dis[i]); pt('\n');

	}

	puts("Yes");

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

#define INL inline

#define REG register

#define DB double

#define LDB long double

#define ULL unsigned long long

#define LL long long



#define RPT(i,x,y) for (REG int i=(x);i<(y);i++)

#define DRPT(i,x,y) for (REG int i=(x);i>(y);i--)

#define MST(a,b) memset((a),(b),sizeof(a))

#define MRK() cout<<"Mark"<<endl;

#define WRT(x) cout<<#x<<" = "<<(x)<<endl;



#define MAXN 110000

#define MAXM 10000

#define MOD 998244353

#define INF 0x3f3f3f3f

#define LLINF 0x3f3f3f3f3f3f3f3f

#define EPS 1e-5



#define _ 0

using namespace std;



int pa[MAXN],dis[MAXN];



int getpa(int x)

{

	if (pa[x]==x)

		return x;

	int f=pa[x];

	pa[x]=getpa(pa[x]);

	dis[x]+=dis[f];

	return pa[x];

}



bool merge(int x,int y,int d)

{

	int px=getpa(x),py=getpa(y);

	if (px==py && d!=dis[x]-dis[y])

		return false;

	pa[px]=py;

	dis[px]=d+dis[y]-dis[x];

	return true;

}



int n,m;



int main()

{

	int x,y,z;

	cin>>n>>m;

	RPT(i,1,n+1)

		pa[i]=i;

	RPT(i,0,m)

	{

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

		if (!merge(y,x,z))

		{

			cout<<"No";

			return 0;

		}

		/*

		cout<<endl<<"--------------\n\n";

		RPT(i,1,n+1)

		{

			cout<<pa[i]<<' '<<dis[i]<<endl;

		}

		*/

	}

	cout<<"Yes";

	return ~~(0^_^0);

}




// Faster C++ solution for the same problem (measured speedup: 5.383404730722329x):
// luogu-judger-enable-o2

// SeptEtavioxy

#include<cstdio>

#include<cctype>

#include<cstring>

#include<algorithm>

#include<cmath>

#define re register

#define ll long long

#define il inline

#define rep(i,s,t) for(re int i=(s);i<=(t);i++)

#define rev_rep(i,s,t) for(re int i=(s);i>=(t);i--)

#define each(i,u) for(int i=head[u];i;i=bow[i].nxt)

#define pt(ch) putchar(ch)

#define pti(x) printf("%d",x)

#define ptll(x) printf("%lld",x)

#define file(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)

using namespace std;

// c_ints

il int ci(){

	re char ch;int f=1;

	while(!isdigit(ch=getchar()))f= ch=='-'?-1:1 ;

	re int x= ch^'0';

	while(isdigit(ch=getchar()))x=(x*10)+(ch^'0');

	return f*x;

}

enum{N=100024};

int fa[N],dis[N];

void fd(int x){

	if( fa[x]==x ) return ;

	fd(fa[x]);

	dis[x]+= dis[fa[x]];

	fa[x]= fa[fa[x]];

}

int main(){

	int n=ci(), m=ci();

	rep(i,1,n) fa[i]= i;

	while( m-- ){

		int l=ci(), r=ci(), d=ci();

		fd(l), fd(r);

		if( fa[l]==fa[r] ){

			if( dis[r]-dis[l]!=d ){

				puts("No");

				return 0;

			}

		}

		else{

			int fl=fa[l], fr=fa[r];

			int x= dis[l]+d-dis[r];

//			printf("%d %d\n",fl,fr);

//			if( x<0 ){

//				puts("No");

//				return 0;

//			}

			dis[fr]= x;

			fa[fr]= fl;

		}

//		printf("fa :");rep(i,1,n) printf("%d ",fa[i]); pt('\n');

//		printf("dis:");rep(i,1,n) printf("%d ",dis[i]); pt('\n');

	}

	puts("Yes");

	return 0;

}
// Slower C++ solution:
#include <cstdio>

#include <iostream>

#include <algorithm>

#include <cstring>

#include <queue>



using namespace std;



struct edge

{

    int v,w,nxt;

}e[400050];



int head[100050],ecnt;



void adde(int u,int v,int w)

{

    e[++ecnt].v = v;

    e[ecnt].w = w;

    e[ecnt].nxt = head[u];

    head[u] = ecnt;

}



int N,M;

int l[200050],r[200050];

int d[200050];

long long dist[100005];

queue<int> que;

bool vis[100050],inq[100050];



bool spfa(int st)

{

    que.push(st);

    inq[st] = true;

    dist[st] = 0;

    long long curmax = 0,curmin = 0;

    while(!que.empty())

    {

        int u = que.front();

        que.pop();

        for(int i = head[u];i;i = e[i].nxt)

        {

            int v = e[i].v;

            if(dist[v] == 12345678987654321)

            {

                dist[v] = dist[u] + e[i].w;

                curmax = max(curmax,dist[v]);

                curmin = min(curmin,dist[v]);

                if(curmax - curmin > 1000000000)

                    return false;

                vis[v] = 1;

                if(!inq[v])

                    que.push(v);

            }

            else if(dist[v] != dist[u] + e[i].w)

                return false;

        }

        inq[u] = false;

    }

    return true;

}



int main()

{

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

        dist[i] = 12345678987654321;

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

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

    {

        scanf("%d%d%d",&l[i],&r[i],&d[i]);

        adde(l[i],r[i],d[i]);

        adde(r[i],l[i],-d[i]);

    }

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

    {

        if(!vis[i])

        {

            vis[i] = 1;bool l = spfa(i);

            if(!l)

            {

                printf("No\n");

                return 0;

            }

        }

    }

    printf("Yes\n");

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.9528204387079224x):
# include <cstdio>

# include <queue>

# define N 100000

# define M 200000

# define R register

# define inf 1000000000

# define C const int

using namespace std;

inline int r()

{

	int f = 1,x = 0;

	char c = getchar();

	

	while(c < '0' || c > '9'){

		if(c == '-') f = -1;

		c = getchar();

	}

	

	while(c >= '0' && c <= '9'){

		x = x * 10 + c - '0';

		c = getchar();

	}

	

	return x *= f;

}

struct edge

{

	int from,to,wi;

} e[2 * M + 42];

long long dis[N + 42],head[N + 42],cnt;

bool vis[N + 42],flag;



inline void add(C u,C v,C wi)

{

	e[++cnt].from = head[u];

	e[cnt].to = v;

	e[cnt].wi = wi;

	head[u] = cnt;

}



queue <int> q;

int n,m;

inline bool SPFA(int s);

int main()

{	

	n = r();m = r();

	

	int a,b,c;

	while(m--){

		a = r();b = r();c = r();

		add(a,b,c);

		add(b,a,-c);

	}

	

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

		if(!vis[i] && SPFA(i)) break;

	

	if(flag == false) puts("Yes");

	else puts("No");

}

inline bool SPFA(int s)

{

	if(flag) return true;

    vis[s] = true;

    int v;

    for(int i = head[s]; i ; i = e[i].from)

    {

    	v = e[i].to;

        if(!vis[v]) dis[v] = dis[s] + e[i].wi,SPFA(v);

        else if(dis[v] != dis[s] + e[i].wi) return flag = true;

    }

    return false;

}
// Slower C++ solution:
# include <cstring>

# include <cstdio>

# include <iostream>

# include <queue>

# define N 100050

# define M 200050 

# define WQD 0x7f7f7f7f

int n;

int m;

struct Edge{int next,to, w;}  e[M<<1];

int head[N+1]; 

int dis[N+1];

bool vis[N+1];

bool book[ N + 1 ] ;

bool spfa(int s);

using namespace std;

int main()

{

	memset(dis,0x7f,sizeof(dis));

	memset(book,0,sizeof(book));

	ios::sync_with_stdio ( false ) ;

	int u,v,w;

	memset(head,-1,sizeof(head));

	cin>>n>>m;

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

	{

		cin>>u>>v>>w;

		e[i]=(Edge){head[u],v,w};head[u]=i;

		e[m+i]=(Edge){head[v],u,-w};head[v]=m+i;

	}

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

		if(!vis[i]) 

		{

			vis[i]=1;

			if(!spfa(i))  {cout<<"No";return 0;}

		}

	cout<<"Yes";

	return 0;

}

bool spfa(int s)

{

 	queue<int>q;

//	memset(book,0,sizeof(book));

//	memset(dis,0x7f,sizeof(dis));

	dis[s]=0;

	q.push(s);book[s]=1;

	while(q.size()>0)

	{

		int k=q.front();q.pop();

		book[k]=0;

		for(int i=head[k]; i!=-1; i=e[i].next)

		{

			int v=e[i].to;

			if(dis[v]==WQD ) 

			{				

				dis[v]=dis[k]+e[i].w;

				if( ! book[v])	{q.push(v);	book[v]=1;}

				vis[v]=1;

			}

			else if(  (dis[v]!=dis[k]+e[i].w) )	return false;

		}		

    }

	return true;

}

// Faster C++ solution for the same problem (measured speedup: 2.0899391317653975x):
# include <cstdio>

# include <queue>

# define N 100000

# define M 200000

# define R register

# define inf 1000000000

# define C const int

using namespace std;

inline int r()

{

	int f = 1,x = 0;

	char c = getchar();

	

	while(c < '0' || c > '9'){

		if(c == '-') f = -1;

		c = getchar();

	}

	

	while(c >= '0' && c <= '9'){

		x = x * 10 + c - '0';

		c = getchar();

	}

	

	return x *= f;

}

struct edge

{

	int from,to,wi;

} e[2 * M + 42];

long long dis[N + 42],head[N + 42],cnt;

bool vis[N + 42],flag;



inline void add(C u,C v,C wi)

{

	e[++cnt].from = head[u];

	e[cnt].to = v;

	e[cnt].wi = wi;

	head[u] = cnt;

}



queue <int> q;

int n,m;

inline bool SPFA(int s);

int main()

{	

	n = r();m = r();

	

	int a,b,c;

	while(m--){

		a = r();b = r();c = r();

		add(a,b,c);

		add(b,a,-c);

	}

	

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

		if(!vis[i] && SPFA(i)) break;

	

	if(flag == false) puts("Yes");

	else puts("No");

}

inline bool SPFA(int s)

{

	if(flag) return true;

    vis[s] = true;

    int v;

    for(int i = head[s]; i ; i = e[i].from)

    {

    	v = e[i].to;

        if(!vis[v]) dis[v] = dis[s] + e[i].wi,SPFA(v);

        else if(dis[v] != dis[s] + e[i].wi) return flag = true;

    }

    return false;

}
// Slower C++ solution:
# include <cstring>

# include <cstdio>

# include <iostream>

# include <queue>

# define N 100050 //N为顶点个数 

# define M 200050 //N为顶点个数 

# define WQD 0x7f7f7f7f//无穷大 

int n;//图的顶点个数

int m;//图的边数 

struct Edge{int next,to, w;}  e[M<<1];//不用0号单元 

int head[N+1]; 

int dis[N+1];//存放源点到其他点的路径

bool vis[N+1];

bool book[N+1];

bool spfa(int s);//差分约束判断 

using namespace std;

int main()

{

	ios::sync_with_stdio ( false ) ;

	int u,v,w;

	memset(head,-1,sizeof(head));

	cin>>n>>m;

	for(int i=1; i<=m; i++)  //本题约束关系为=，要添加两条边 

	{

		cin>>u>>v>>w;//输入第i条边 ,i为编号 

		e[i]=(Edge){head[u],v,w};head[u]=i;

		e[m+i]=(Edge){head[v],u,-w};head[v]=m+i;

	}

	memset(book,0,sizeof(book));

	memset(dis,0x7f,sizeof(dis));

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

		if(!vis[i]) 

		{

			vis[i]=1;

			if(spfa(i)==false)  {cout<<"No";return 0;}

		}

	cout<<"Yes";

	return 0;

}

bool spfa(int s)

{

 	queue<int>q;

 	//memset(book,0,sizeof(book));

	//memset(dis,0x7f,sizeof(dis));

	dis[s]=0;

	q.push(s);book[s]=1;

	while(q.size()>0)//如果没松弛就松弛，如果松弛过就判断是否符合约束条件，如果自相矛盾就是不可能的数据 

	{

		int k=q.front();q.pop();//对头元素出队 

		book[k]=0;

		for(int i=head[k]; i!=-1; i=e[i].next)

		{

			int v=e[i].to;

			if(dis[v]==WQD )//如果v点没松弛过，就松弛更新dis[v]的值 

				//题目的约束条件是= 

				{				

					dis[v]=dis[k]+e[i].w;//更新 

					if(book[v]==0)	{q.push(v);	book[v]=1;}//入队标记

					vis[v]=1;//标记该点已经松弛过 

				}

			else if(dis[v]!=dis[k]+e[i].w)	return false;//这里也可以用不等于，根据题意理解差分系统约束条件 

		}		

    }

	return true;//别掉了这句 

}

// Faster C++ solution for the same problem (measured speedup: 2.0873638905149026x):
# include <cstdio>

# include <queue>

# define N 100000

# define M 200000

# define R register

# define inf 1000000000

# define C const int

using namespace std;

inline int r()

{

	int f = 1,x = 0;

	char c = getchar();

	

	while(c < '0' || c > '9'){

		if(c == '-') f = -1;

		c = getchar();

	}

	

	while(c >= '0' && c <= '9'){

		x = x * 10 + c - '0';

		c = getchar();

	}

	

	return x *= f;

}

struct edge

{

	int from,to,wi;

} e[2 * M + 42];

long long dis[N + 42],head[N + 42],cnt;

bool vis[N + 42],flag;



inline void add(C u,C v,C wi)

{

	e[++cnt].from = head[u];

	e[cnt].to = v;

	e[cnt].wi = wi;

	head[u] = cnt;

}



queue <int> q;

int n,m;

inline bool SPFA(int s);

int main()

{	

	n = r();m = r();

	

	int a,b,c;

	while(m--){

		a = r();b = r();c = r();

		add(a,b,c);

		add(b,a,-c);

	}

	

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

		if(!vis[i] && SPFA(i)) break;

	

	if(flag == false) puts("Yes");

	else puts("No");

}

inline bool SPFA(int s)

{

	if(flag) return true;

    vis[s] = true;

    int v;

    for(int i = head[s]; i ; i = e[i].from)

    {

    	v = e[i].to;

        if(!vis[v]) dis[v] = dis[s] + e[i].wi,SPFA(v);

        else if(dis[v] != dis[s] + e[i].wi) return flag = true;

    }

    return false;

}
// Slower C++ solution:
# include <cstdio>

# include <iostream>

# include <cstring>

# include <algorithm>

# include <queue>

# define N 100001

# define M 200001

# define _cin ios::sync_with_stdio(false)

# define Inf 0x7f7f7f7f

using namespace std;

struct ege

{

	int next;

	int to;

	int w;

}e[M<<1];

int n;//人数 

int m;//信息数 

int book[N+1];

int head[N+1];

int dis[N+1];

bool vis[N+1];

bool spfa(int x);

int main()

{

	_cin;

	

	int u,v,w;

	cin>>n>>m;

	memset(head,-1,sizeof(head));

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

	{

		cin>>u>>v>>w;

		//建立双向边 

		/*e[i].next=head[u];

		e[i].to=v;

		e[i].w=w;

		head[u]=i;

		e[i+m].next=head[v];

		e[i+m].to=u;

		e[i+m].w=-w;

		head[v]=i+m;

		*/

		e[i]=(ege){head[u],v,w};head[u]=i;

		e[m+i]=(ege){head[v],u,-w};head[v]=m+i;		

	}

	memset(book,0,sizeof(book));

	memset(dis,0x7f,sizeof(dis));

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

	if(!vis[i])//表示两点连通

	{

		vis[i]=1;//连通就变成真值 

		if(spfa(i)==false)	{cout<<"No"<<endl;return 0;}

	} 

	cout<<"Yes"<<endl;

	return 0;

}

bool spfa(int x)

{

	queue <int>q;

	dis[x]=0;

	q.push(x);book[x]=1;//标记已经进队列的点 

	while(q.size()>0)

	{

		int k=q.front();//取头元素

		q.pop();//头元素出队列

		book[k]=0;

		for(int i=head[k]; i!=-1; i=e[i].next)

		{

			if(dis[e[i].to]==Inf && dis[k]<Inf)

			{

				dis[e[i].to]=dis[k]+e[i].w;

				//如果下一个点没有被标记，将这个点标记，进队列 

				if(book[e[i].to]==0)	{q.push(e[i].to);book[e[i].to]=1;}

				vis[e[i].to]=1;

			} 

			//与已知矛盾，即任意两点的距离都不能有两个值 

			//表示k点已被改变值，下一个点也已经改变值，但是新值与旧值不等 

			else if(dis[k]<Inf && dis[e[i].to]<Inf && dis[e[i].to]!=dis[k]+e[i].w) return false;

		} 

	}

	return true;

}

// Faster C++ solution for the same problem (measured speedup: 2.4228590460738046x):
# include <cstdio>

# include <queue>

# define N 100000

# define M 200000

# define R register

# define inf 1000000000

# define C const int

using namespace std;

inline int r()

{

	int f = 1,x = 0;

	char c = getchar();

	

	while(c < '0' || c > '9'){

		if(c == '-') f = -1;

		c = getchar();

	}

	

	while(c >= '0' && c <= '9'){

		x = x * 10 + c - '0';

		c = getchar();

	}

	

	return x *= f;

}

struct edge

{

	int from,to,wi;

} e[2 * M + 42];

long long dis[N + 42],head[N + 42],cnt;

bool vis[N + 42],flag;



inline void add(C u,C v,C wi)

{

	e[++cnt].from = head[u];

	e[cnt].to = v;

	e[cnt].wi = wi;

	head[u] = cnt;

}



queue <int> q;

int n,m;

inline bool SPFA(int s);

int main()

{	

	n = r();m = r();

	

	int a,b,c;

	while(m--){

		a = r();b = r();c = r();

		add(a,b,c);

		add(b,a,-c);

	}

	

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

		if(!vis[i] && SPFA(i)) break;

	

	if(flag == false) puts("Yes");

	else puts("No");

}

inline bool SPFA(int s)

{

	if(flag) return true;

    vis[s] = true;

    int v;

    for(int i = head[s]; i ; i = e[i].from)

    {

    	v = e[i].to;

        if(!vis[v]) dis[v] = dis[s] + e[i].wi,SPFA(v);

        else if(dis[v] != dis[s] + e[i].wi) return flag = true;

    }

    return false;

}
// Slower C++ solution:
#include <cstdio>

#include <iostream>

#include <algorithm>

#include <cstring>

#include <queue>

#define N 100001

#define M 200001

#define INF 0x7fffffff

#define ri register int

#define in inline

using namespace std;

struct edge

{

	int to,w,next;

}e[M<<1];

//vis数组表示已松弛的点

//book数组表示进入队列的点 

int head[N],vis[N],dis[N];

int m,n;

bool book[N];

in bool spfa(int s);

int main()

{

	ios::sync_with_stdio(false);

	int u,v,w;

	cin>>n>>m;

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

	{

		cin>>u>>v>>w;

		e[i]=(edge) {v,w,head[u]}; head[u]=i;

		e[i+m]=(edge) {u,-w,head[v]}; head[v]=i+m;

	}

	//一组数据为一个问题，不能将fill数组放在spfa里 

	fill(dis+1,dis+n+1,INF);

	//所有约束条件需要考虑到

	//可能有多个分块，前10个约束条件与后10个 无关联 

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

		if(!vis[i])

		{

			if(spfa(i))

			{cout<<"No"; return 0;}

			vis[i]=1;

		}	

	cout<<"Yes";

	return 0;

}

in bool spfa(int s)

{

	queue <int> q;

	int k;

	q.push(s); book[s]=1;

	dis[s]=0;

	while(q.size())

	{

		k=q.front(); q.pop();

		book[k]=0;//出队列应置为0 

		for(ri i=head[k]; i ;i=e[i].next)

		{

			int v=e[i].to;

			if(!vis[v]&& dis[k]<INF)

			{

				dis[v]=dis[k]+e[i].w;

				if(!book[v])

				{q.push(v); book[v]=1;}

				vis[v]=1;

			}

			else if(dis[k]<INF && dis[v]<INF && dis[v]!=dis[k]+e[i].w) return true;

			//此时相当于自相矛盾

			//思想：即先认定一开始所给条件均正确（此时松弛）

		    //最后再来验证接下来的条件是否满足原先条件 

		}

	}

	return false;

}

// Faster C++ solution for the same problem (measured speedup: 1.1087870923394922x):
# include <cstdio>

# include <queue>

# define N 100000

# define M 200000

# define R register

# define inf 1000000000

# define C const int

using namespace std;

inline int r()

{

	int f = 1,x = 0;

	char c = getchar();

	

	while(c < '0' || c > '9'){

		if(c == '-') f = -1;

		c = getchar();

	}

	

	while(c >= '0' && c <= '9'){

		x = x * 10 + c - '0';

		c = getchar();

	}

	

	return x *= f;

}

struct edge

{

	int from,to,wi;

} e[2 * M + 42];

long long dis[N + 42],head[N + 42],cnt;

bool vis[N + 42],flag;



inline void add(C u,C v,C wi)

{

	e[++cnt].from = head[u];

	e[cnt].to = v;

	e[cnt].wi = wi;

	head[u] = cnt;

}



queue <int> q;

int n,m;

inline bool SPFA(int s);

int main()

{	

	n = r();m = r();

	

	int a,b,c;

	while(m--){

		a = r();b = r();c = r();

		add(a,b,c);

		add(b,a,-c);

	}

	

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

		if(!vis[i] && SPFA(i)) break;

	

	if(flag == false) puts("Yes");

	else puts("No");

}

inline bool SPFA(int s)

{

	if(flag) return true;

    vis[s] = true;

    int v;

    for(int i = head[s]; i ; i = e[i].from)

    {

    	v = e[i].to;

        if(!vis[v]) dis[v] = dis[s] + e[i].wi,SPFA(v);

        else if(dis[v] != dis[s] + e[i].wi) return flag = true;

    }

    return false;

}