stablegradients/pie-gem5-pairs huggingface dataset:
// 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 && dis[k]<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]<WQD && dis[k]<WQD && dis[v]!=dis[k]+e[i].w)	return false;

		}		

    }

	return true;//别掉了这句 

}

// Faster C++ solution for the same problem (measured speedup: 2.1349791357487935x):
# 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]) //如果i点没有校验，就用spfa校验和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 && dis[k]<WQD && dis[v]!=dis[k]+e[i].w)	return false;

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

			{				

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

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

				vis[v]=1;//标记该点已经检验过 

			}

			

		}		

    }

	return true;//别掉了这句 

}

// Faster C++ solution for the same problem (measured speedup: 2.087067261099466x):
# 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<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N=100005;

struct node

{

	int to;

	ll v;

	node(int a=0,int b=0){to=a;v=b;}

};

vector<node> path[N];

bool vis[N],use[N];

ll d[N];

bool dfs(int o)

{

	//if(vis[o]) return false;

	vis[o]=true;

	use[o]=true;

	for(int i=0;i<path[o].size();i++)

	{

		node e=path[o][i];

		if(d[e.to]>d[o]+e.v)

		{

			if(use[e.to]) return true;

			d[e.to]=d[o]+e.v;

			if(dfs(e.to)) return true;

		}

	}

	use[o]=false;

	return false;

}

int main()

{

	int n,m,a,b;

	ll dd;

	scanf("%d%d",&n,&m);

	while(m--)

	{

		scanf("%d%d%lld",&a,&b,&dd);

		path[a].push_back(node(b,dd));

		path[b].push_back(node(a,-dd));

	}

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

	

	bool bo=false;

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

	{

		if(vis[i]) continue;

		d[i]=0;

		if(dfs(i)) {bo=true;break;}

	}

	if(bo) puts("No");

	else puts("Yes");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.8255348437852947x):
# 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<bits/stdc++.h>

using namespace std;

const int MAXN=100007,MAXM=200007,MAX=1061109567;

typedef long long ll;

struct node {

	int v,w;

	node(int x=0,int y=0) {

		v=x,w=y;

	}

};

int deg[MAXN],X,n,m,x1,y,x2,tot[MAXN];

ll pos[MAXN];

bool vis[MAXN];

char c;

vector<node> edge[MAXN];

int read() {

	X=0,c=getchar();

	while(!isdigit(c))c=getchar();

	while(isdigit(c))X=(X<<1)+(X<<3)+c-'0',c=getchar();

	return X;

}

bool ok;

bool check(int &u) {

	vis[u]=true;

	for(int i=0; i<tot[u]; i++) {

		if(vis[edge[u][i].v]) {

			if(pos[edge[u][i].v]-edge[u][i].w!=pos[u])return false;

		} else {

			pos[edge[u][i].v]=pos[u]+edge[u][i].w;

			if(!check(edge[u][i].v))return false;

			else continue;

		}

	}

	return true;

}

int main() {

		n=read(),m=read();

		if(!m){

			cout<<"Yes";

			return 0;

		}

		for(int i=0; i<m; i++) {

			x1=read(),x2=read(),y=read();

			tot[x1]++;

			deg[x2]++;

			edge[x1].push_back(node(x2,y));

		}

		for(int i=0; i<n; i++)if(!deg[i]&&tot[i]) {

				ok=1;

				if(!check(i)) {

					cout<<"No";

					return 0;

				}

			};

		if(!ok) {

			cout<<"No";

			return 0;

		}

		cout<<"Yes";

		return 0;

}


// Faster C++ solution for the same problem (measured speedup: 3.826289320855264x):
# 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 <bits/stdc++.h>

#define LL long long

#define mp make_pair

#define pb push_back

#define INF (1<<29)

using namespace std;

typedef pair<int,int>pii;

int n,m;

vector<pii>G[200010];

int col[200010];

int vis[200010];

bool dfs(int x,int co){

//	cout<<"In:"<<x<<' '<<co<<endl;

	if(vis[x]!=-1)return col[x]==co;

	vis[x]=1;

	col[x]=co;

	for(pii i:G[x]){

		if(dfs(i.first,co+i.second)==0)return false;

//		else{

//			if(vis[i.first]!=co+i.second)return false;

//		}

	}

	return true;

}

int main(){

//	freopen("produce/People.txt","r",stdin);

	cin>>n>>m;

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

	if(m==0){

		cout<<"Yes\n";

		return 0;

	}

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

		int l,r,d;

		cin>>l>>r>>d;

		G[l].pb(mp(r,d));

		G[r].pb(mp(l,-d));

	}

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

		if(vis[i]!=-1)continue;

		memset(col,0,sizeof(col));

		if(dfs(i,0)==0){

			cout<<"No\n";

			return 0;

		}

//		cout<<"-----------------------\n";

	}

	cout<<"Yes\n";

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 8.981246159301836x):
# 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<cstring>

#include<iostream>

#include<algorithm>

#define int long long

using namespace std;

int n,m,cnt=0;

int head[410000],nxt[410000],to[410000],val[410000];

int ma=0,mi=0;

int q[1000000],dis[100100],f[100100],vis[100100];

void addedge(int x,int y,int z)

{

    cnt++;

    nxt[cnt]=head[x];

    head[x]=cnt;

    to[cnt]=y;

    val[cnt]=z;

}

bool spfa(int x)

{

    int l=0,r=1;

    q[1]=x;vis[x]=1;dis[x]=0;

    while(l<r)

    {

        int u=q[++l];

        for(int i=head[u];i!=-1;i=nxt[i])

        {

            int v=to[i];

            if(dis[v]==12345678987654321)

            {

                dis[v]=dis[u]+val[i];

                ma=max(ma,dis[v]);

                mi=min(mi,dis[v]);

                if(ma-mi>1e9) return 0;

                vis[v]=1;

                if(!f[v]) q[++r]=v,f[v]=1;

            }

            else if(dis[v]!=dis[u]+val[i]) return 0;

        }

        f[u]=0;

    }

    return 1;

}

signed main()

{

//	freopen("line.in","r",stdin);

//	freopen("line.out","w",stdout);

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

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

        dis[i]=12345678987654321;

    scanf("%lld%lld",&n,&m);

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

    {

        int x,y,z;

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

        addedge(x,y,z);

        addedge(y,x,-z);

    }

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

        if(!vis[i]) {if(!spfa(i)) {printf("No");return 0;}}

    printf("Yes");

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.5610000024289x):
# 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<bits/stdc++.h>

#define R(i,j,k) for(int i=j;i<=k;i++)

using namespace std;

const int maxn=1e5+5;

int n,m;

struct Union_Set {

	int p[maxn],v[maxn];

	Union_Set() {

		R(i,1,maxn-1) p[i]=i;

	}

	void fp(int x) {

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

		fp(p[x]);

		v[x]+=v[p[x]];

		p[x]=p[p[x]];

	}

	bool merge(int x,int y,int val) {

		fp(x); fp(y);

		int X=p[x],Y=p[y];

		if(X==Y) {

			int v1=-v[x],v2=-v[y];

			if(v1+val==v2) return true;

			return false;

		}

		val=val+v[y]-v[x];

		p[X]=Y;

		v[X]=val;

		return true;

	}

}us;

int main() {

#ifdef LOCAL

	//freopen("line.in","r",stdin);

#endif

	cin>>n>>m;

	R(i,1,m) {

		int Li,Ri,Di;

		cin>>Li>>Ri>>Di;

		if(!us.merge(Li,Ri,Di)) {

			cout<<"No"<<endl;

			return 0;

		}

	}

	cout<<"Yes"<<endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.5249739500472421x):
# 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: 1.9381854038061064x):
#include <bits/stdc++.h>

using namespace std;



#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)

#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)



mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());



template <typename T>

inline void chkmax(T &x, T y) { if (x < y) x = y; }



template <typename T>

inline void chkmin(T &x, T y) { if (x > y) x = y; }



inline int read() {

  #define nc getchar()

  int x = 0;

  char c = nc;

  while (c < 48) c = nc;

  while (c > 47) x = (x << 3) + (x << 1) + (c ^ 48), c = nc;

  return x;

  #undef nc

}



const int maxn = 4e5 + 10;

bool vis[maxn];

int n, m, h[maxn], val[maxn];



struct edges {

  int nxt, to, w;

} e[maxn];



void addline(int u, int v, int w) {

  static int cnt = 1;

  e[++cnt] = edges{h[u], v, w}, h[u] = cnt;

}



bool flgans = 1;



void dfs(int u) {

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

    int v = e[i].to;

    if (vis[v]) {

      flgans &= val[v] - val[u] == e[i].w;

    } else {

      vis[v] = 1, val[v] = val[u] + e[i].w, dfs(v);

    }

  }

}



int main() {

  scanf("%d %d", &n, &m);

  rep(i, 1, m) {

    int x = read(), y = read(), w = read();

    addline(x, y, w), addline(y, x, -w);

  }

  rep(i, 1, n) {

    if (!vis[i]) vis[i] = 1, dfs(i);

    if (!flgans) return puts("No"), 0;

  }

  puts("Yes");

  return 0;

}
// 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: 1.9357971548245332x):
#include <bits/stdc++.h>

using namespace std;



#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)

#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)



mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());



template <typename T>

inline void chkmax(T &x, T y) { if (x < y) x = y; }



template <typename T>

inline void chkmin(T &x, T y) { if (x > y) x = y; }



inline int read() {

  #define nc getchar()

  int x = 0;

  char c = nc;

  while (c < 48) c = nc;

  while (c > 47) x = (x << 3) + (x << 1) + (c ^ 48), c = nc;

  return x;

  #undef nc

}



const int maxn = 4e5 + 10;

bool vis[maxn];

int n, m, h[maxn], val[maxn];



struct edges {

  int nxt, to, w;

} e[maxn];



void addline(int u, int v, int w) {

  static int cnt = 1;

  e[++cnt] = edges{h[u], v, w}, h[u] = cnt;

}



bool flgans = 1;



void dfs(int u) {

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

    int v = e[i].to;

    if (vis[v]) {

      flgans &= val[v] - val[u] == e[i].w;

    } else {

      vis[v] = 1, val[v] = val[u] + e[i].w, dfs(v);

    }

  }

}



int main() {

  scanf("%d %d", &n, &m);

  rep(i, 1, m) {

    int x = read(), y = read(), w = read();

    addline(x, y, w), addline(y, x, -w);

  }

  rep(i, 1, n) {

    if (!vis[i]) vis[i] = 1, dfs(i);

    if (!flgans) return puts("No"), 0;

  }

  puts("Yes");

  return 0;

}