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

#include<iostream>

#include<cstring>

using namespace std;

struct node_ {

	int v,c,next;

} node[3000001];

int head[1000001],e;

void addnode(int u,int v,int c) {

	e++;

	node[e].c=c;

	node[e].v=v;

	node[e].next=head[u];

	head[u]=e;

}

int n,m;

bool b[1000001],flag;

int d[1000001];

int L,R,D;

bool dfs(int x) {

	b[x]=1;

	for(int i=head[x]; i!=0; i=node[i].next) {

		int y=node[i].v,c=node[i].c;

		if(d[y]>d[x]+c) {

			if(b[y]) return 1;

			d[y]=d[x]+c;

			if(dfs(y))return 1;

		}

	}

	b[x]=0;

	return 0;

}

int main() {

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

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

		scanf("%d%d%d",&L,&R,&D);

		addnode(R,L,D);

		addnode(L,R,-D);

	}

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

		addnode(0,i,0);

	}

	memset(b,0,sizeof(b));

	memset(d,1000000,sizeof(d));

	d[0]=0;

	if(dfs(0)) printf("No\n");

	else printf("Yes\n");

	return 0;

}

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

#include<cstdio>

using namespace std;

struct Edge

{

	int to,next,cost;	

}e[400005];

int head[100005],cnt=0;

bool vis[100005];

int d[100005];

bool use[100005];

void addedge(int from,int to,int cost)

{

	e[++cnt].to=to;

	e[cnt].cost=cost;

	e[cnt].next=head[from];

	head[from]=cnt;

}

bool flag=0;

void dfs(int x)

{

	vis[x]=1;

	for(int i=head[x];i;i=e[i].next)

	{

		int w=e[i].cost,v=e[i].to;

		if(d[v]>d[x]+w)

		{

			d[v]=d[x]+w;

			if(vis[v])

			{

				flag=1;

				return;

			}

			dfs(v);	

		}	

	} 

	vis[x]=0;

	return;

}

inline int read()

{

	int s=0,f=1;char x=getchar();

	while(!isdigit(x))

	{

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

		x=getchar();

	}

	while(isdigit(x))

	{

		s=(s<<1)+(s<<3)+(x^48);

		x=getchar();

	}

	return s*f;

}

int main()

{

	int n,m;

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

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

	{

		int x,y,z;

		x=read();y=read();z=read();

		addedge(y,x,z);

		addedge(x,y,-z);

	}

	flag=0;

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

	{

		d[i]=0;

		if(!use[i])

		{

			use[i]=1;

			dfs(i);

		}	

	}

	if(flag) cout<<"No";

	else cout<<"Yes";

	return 0;

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

using namespace std;

const int MAXN=100007;

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,x2,y,tot[MAXN];

ll pos[MAXN];

bool vis[MAXN];

char c;

vector<node> edge[MAXN];

inline char nc(){

	static char buf[100000],*p1=buf,*p2=buf;

	return p2==p1&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;

}

int read() {

    X=0,c=nc();

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

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

    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){

            puts("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)) {

                    puts("No");

                    return 0;

                }

            };

        if(!ok) {

            puts("No");

            return 0;

        }

        puts("Yes");

        return 0;

}

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

#include<cstdio>

using namespace std;

struct Edge

{

	int to,next,cost;	

}e[400005];

int head[100005],cnt=0;

bool vis[100005];

int d[100005];

bool use[100005];

void addedge(int from,int to,int cost)

{

	e[++cnt].to=to;

	e[cnt].cost=cost;

	e[cnt].next=head[from];

	head[from]=cnt;

}

bool flag=0;

void dfs(int x)

{

	vis[x]=1;

	for(int i=head[x];i;i=e[i].next)

	{

		int w=e[i].cost,v=e[i].to;

		if(d[v]>d[x]+w)

		{

			d[v]=d[x]+w;

			if(vis[v])

			{

				flag=1;

				return;

			}

			dfs(v);	

		}	

	} 

	vis[x]=0;

	return;

}

inline int read()

{

	int s=0,f=1;char x=getchar();

	while(!isdigit(x))

	{

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

		x=getchar();

	}

	while(isdigit(x))

	{

		s=(s<<1)+(s<<3)+(x^48);

		x=getchar();

	}

	return s*f;

}

int main()

{

	int n,m;

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

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

	{

		int x,y,z;

		x=read();y=read();z=read();

		addedge(y,x,z);

		addedge(x,y,-z);

	}

	flag=0;

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

	{

		d[i]=0;

		if(!use[i])

		{

			use[i]=1;

			dfs(i);

		}	

	}

	if(flag) cout<<"No";

	else cout<<"Yes";

	return 0;

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

#define base 200000

#define inf 0x3f3f3f3f

using namespace std;

int n,m,x,y,w,ans,maxn,minn,dist[100010],vi[100010];

vector<int> g[100010],l[100010];

queue<int> q;

bool flag=false;



bool spfa(int s){

	memset(dist,0x3f,sizeof(dist));

	dist[s]=0,maxn=minn=0,q.push(s),vi[s]=1;

	while(!q.empty()){

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

		for(int i=0;i<g[u].size();i++){

			int v=g[u][i];

			if(!vi[v]){

				dist[v]=dist[u]+l[u][i];

				q.push(v),vi[v]=1;

				maxn=max(maxn,dist[v]),minn=min(minn,dist[v]);

			}

			else if(dist[v]!=dist[u]+l[u][i]) return true;

		}

	}

	return false;

}



int main(){

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

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

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

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

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

		g[x].push_back(y),l[x].push_back(w),g[y].push_back(x),l[y].push_back(-w);

	}

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

		if(!vi[i]){

			flag=spfa(i);

			if(flag){

//				printf("impossible");

				printf("No");

				return 0;

			}

			ans=max(ans,maxn-minn);

		}

	}

//	printf("%d",ans);

	printf("Yes");

}

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

#include<cstdio>

using namespace std;

struct Edge

{

	int to,next,cost;	

}e[400005];

int head[100005],cnt=0;

bool vis[100005];

int d[100005];

bool use[100005];

void addedge(int from,int to,int cost)

{

	e[++cnt].to=to;

	e[cnt].cost=cost;

	e[cnt].next=head[from];

	head[from]=cnt;

}

bool flag=0;

void dfs(int x)

{

	vis[x]=1;

	for(int i=head[x];i;i=e[i].next)

	{

		int w=e[i].cost,v=e[i].to;

		if(d[v]>d[x]+w)

		{

			d[v]=d[x]+w;

			if(vis[v])

			{

				flag=1;

				return;

			}

			dfs(v);	

		}	

	} 

	vis[x]=0;

	return;

}

inline int read()

{

	int s=0,f=1;char x=getchar();

	while(!isdigit(x))

	{

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

		x=getchar();

	}

	while(isdigit(x))

	{

		s=(s<<1)+(s<<3)+(x^48);

		x=getchar();

	}

	return s*f;

}

int main()

{

	int n,m;

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

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

	{

		int x,y,z;

		x=read();y=read();z=read();

		addedge(y,x,z);

		addedge(x,y,-z);

	}

	flag=0;

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

	{

		d[i]=0;

		if(!use[i])

		{

			use[i]=1;

			dfs(i);

		}	

	}

	if(flag) cout<<"No";

	else cout<<"Yes";

	return 0;

}
// 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()

{

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

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

        dis[i]=12345678987654321;

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

    if(!m) {printf("Yes");return 0;}

    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.202553758180778x):
#include<iostream>

#include<cstdio>

using namespace std;

struct Edge

{

	int to,next,cost;	

}e[400005];

int head[100005],cnt=0;

bool vis[100005];

int d[100005];

bool use[100005];

void addedge(int from,int to,int cost)

{

	e[++cnt].to=to;

	e[cnt].cost=cost;

	e[cnt].next=head[from];

	head[from]=cnt;

}

bool flag=0;

void dfs(int x)

{

	vis[x]=1;

	for(int i=head[x];i;i=e[i].next)

	{

		int w=e[i].cost,v=e[i].to;

		if(d[v]>d[x]+w)

		{

			d[v]=d[x]+w;

			if(vis[v])

			{

				flag=1;

				return;

			}

			dfs(v);	

		}	

	} 

	vis[x]=0;

	return;

}

inline int read()

{

	int s=0,f=1;char x=getchar();

	while(!isdigit(x))

	{

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

		x=getchar();

	}

	while(isdigit(x))

	{

		s=(s<<1)+(s<<3)+(x^48);

		x=getchar();

	}

	return s*f;

}

int main()

{

	int n,m;

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

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

	{

		int x,y,z;

		x=read();y=read();z=read();

		addedge(y,x,z);

		addedge(x,y,-z);

	}

	flag=0;

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

	{

		d[i]=0;

		if(!use[i])

		{

			use[i]=1;

			dfs(i);

		}	

	}

	if(flag) cout<<"No";

	else cout<<"Yes";

	return 0;

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

using namespace std;

inline void fff(){

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

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

}

const int N=1e5+10;

const int INF=0x3f3f3f3f;

inline int read(){

	int x=0,m=1;char ch=getchar();

	while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();

	if(ch=='-') ch=getchar(),m=-1;

	while(ch<='9'&&ch>='0') 

		x=x*10+ch-'0',ch=getchar();

	return x*m;

}

int n,m;

struct Edge{

	int nxt;

	int to,w;

}edge[N<<2];

int head[N],tot=0;

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

	edge[++tot].nxt=head[u];

	edge[tot].to=v;

	edge[tot].w=w;

	head[u]=tot;

}

bool visited[N];

int dist[N],ans,minn,maxx;

queue<int> q;

inline bool SPFA(int str){

	

	q.push(str);

	if(m) minn=INF,maxx=0;

	dist[str]=0;visited[str]=true;

	while(!q.empty()){

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

		visited[u]=false;

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

			Edge e=edge[i];

			if(dist[e.to]<INF){

				if(dist[e.to]!=e.w+dist[u]){

					return false;

				}

				minn=min(minn,dist[e.to]);

				maxx=max(maxx,dist[e.to]);

			}else{

				dist[e.to]=dist[u]+e.w;

				minn=min(minn,dist[e.to]);

				maxx=max(maxx,dist[e.to]);

				if(!visited[e.to]){

					visited[e.to]=true;

					q.push(e.to);

				}

			}

		}

	}

	ans=min(ans,maxx-minn);

	return true;

}

int main(){

//	fff();

	n=read();

	m=read();

	ans=INF;

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

		int u,v,w;

		u=read(),v=read(),w=read();

		add(u,v,w);

		add(v,u,-w);

	}

	memset(dist,INF,sizeof(dist));

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

		if(dist[i]<INF)  continue;

		if(!SPFA(i)){

			printf("No");

			return 0;

		}

	}

	printf("Yes");

}

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

#include<cstdio>

using namespace std;

struct Edge

{

	int to,next,cost;	

}e[400005];

int head[100005],cnt=0;

bool vis[100005];

int d[100005];

bool use[100005];

void addedge(int from,int to,int cost)

{

	e[++cnt].to=to;

	e[cnt].cost=cost;

	e[cnt].next=head[from];

	head[from]=cnt;

}

bool flag=0;

void dfs(int x)

{

	vis[x]=1;

	for(int i=head[x];i;i=e[i].next)

	{

		int w=e[i].cost,v=e[i].to;

		if(d[v]>d[x]+w)

		{

			d[v]=d[x]+w;

			if(vis[v])

			{

				flag=1;

				return;

			}

			dfs(v);	

		}	

	} 

	vis[x]=0;

	return;

}

inline int read()

{

	int s=0,f=1;char x=getchar();

	while(!isdigit(x))

	{

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

		x=getchar();

	}

	while(isdigit(x))

	{

		s=(s<<1)+(s<<3)+(x^48);

		x=getchar();

	}

	return s*f;

}

int main()

{

	int n,m;

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

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

	{

		int x,y,z;

		x=read();y=read();z=read();

		addedge(y,x,z);

		addedge(x,y,-z);

	}

	flag=0;

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

	{

		d[i]=0;

		if(!use[i])

		{

			use[i]=1;

			dfs(i);

		}	

	}

	if(flag) cout<<"No";

	else cout<<"Yes";

	return 0;

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

#include<cstring>

#include<iostream>

#include<algorithm>

#define int long long

using namespace std;

const int Top=6666666666666666;

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]==Top)

            {

                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()

{

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

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

        dis[i]=Top;

    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.194211761262802x):
#include<iostream>

#include<cstdio>

using namespace std;

struct Edge

{

	int to,next,cost;	

}e[400005];

int head[100005],cnt=0;

bool vis[100005];

int d[100005];

bool use[100005];

void addedge(int from,int to,int cost)

{

	e[++cnt].to=to;

	e[cnt].cost=cost;

	e[cnt].next=head[from];

	head[from]=cnt;

}

bool flag=0;

void dfs(int x)

{

	vis[x]=1;

	for(int i=head[x];i;i=e[i].next)

	{

		int w=e[i].cost,v=e[i].to;

		if(d[v]>d[x]+w)

		{

			d[v]=d[x]+w;

			if(vis[v])

			{

				flag=1;

				return;

			}

			dfs(v);	

		}	

	} 

	vis[x]=0;

	return;

}

inline int read()

{

	int s=0,f=1;char x=getchar();

	while(!isdigit(x))

	{

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

		x=getchar();

	}

	while(isdigit(x))

	{

		s=(s<<1)+(s<<3)+(x^48);

		x=getchar();

	}

	return s*f;

}

int main()

{

	int n,m;

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

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

	{

		int x,y,z;

		x=read();y=read();z=read();

		addedge(y,x,z);

		addedge(x,y,-z);

	}

	flag=0;

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

	{

		d[i]=0;

		if(!use[i])

		{

			use[i]=1;

			dfs(i);

		}	

	}

	if(flag) cout<<"No";

	else cout<<"Yes";

	return 0;

}
// 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 use[N];

ll d[N];

bool dfs(int o)

{

	use[o]=true;

	for(int i=path[o].size()-1;i>=0;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;

		path[0].push_back(node(i,0));

	}

	if(dfs(0)) puts("No");

	else puts("Yes");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.480898747283128x):
#include<bits/stdc++.h>

using namespace std;



typedef long long lint;

typedef pair<int, int> P;

#define REP(i, x, n) for(lint i = x ; i < n ; i++)

#define rep(i, n) REP(i, 0, n)

#define repr(i, n) for(lint i = n - 1 ; i >= 0 ; i--)

#define SORT(c) sort((c).begin(), (c).end())



const int IINF = 1e9 + 10;

const lint LLINF = (lint)1e18 + 10;

const lint MOD = (lint)1e9 + 7;

const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};



struct weightedUnionFind{



    vector<int> par, rank, wei;



    void init(int n){

        par.resize(n);

        rank.resize(n, 0);

        wei.resize(n, 0);

        rep(i, n){

            par[i] = i;

        }

        return;

    }



    int root(int x){

        if(par[x] == x){

            return x;

        }else{

            int r = root(par[x]);

            wei[x] += wei[par[x]];

            return par[x] = r;

        }

    }



    bool unite(int x, int y, int w){

        w = -w;

        w += weight(x);

        w -= weight(y);

        int rx = root(x);

        int ry = root(y);

        if(rx == ry){

            return false;

        }

        if(rank[rx] < rank[ry]){

            swap(rx, ry);

            w = -w;

        }

        if(rank[rx] == rank[ry]){

            rank[rx]++;

        }

        par[ry] = rx;

        wei[ry] = w;

        return true;

    }



    bool same(int x, int y){

        return root(x) == root(y);

    }



    int weight(int x){

        root(x);

        return wei[x];

    }



    int diff(int x, int y){

        return weight(x) - weight(y);

    }



};



int main(){

    int n, m;

    cin >> n >> m;

    weightedUnionFind uf;

    uf.init(n);

    bool flag = true;

    rep(i, m){

        int l, r, d;

        cin >> l >> r >> d;

        l--;

        r--;

        if(uf.same(l, r)){

            if(uf.diff(l, r) != d){

                flag = false;

                break;

            }

        }else{

            uf.unite(l, r, d);

        }

    }

    if(flag){

        cout << "Yes" << endl;

    }else{

        cout << "No" << endl;

    }

    return 0;

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

#include<vector>

using namespace std;

int a,b,c,n,m,dis[100005];

bool vis[100005];

struct edge{

	int to,v;

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

};

vector<edge> path[200005];

bool spfa(int x){

	vis[x]=true;

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

		edge e=path[x][i];

		if(dis[e.to]<dis[x]+e.v){

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

			dis[e.to]=dis[x]+e.v;

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

		}

	}

	vis[x]=false;

	return false;

}

int main(){

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

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

		scanf("%d%d%d",&a,&b,&c);//b-a=c

		path[b].push_back(edge(a,c));

		path[a].push_back(edge(b,-c));

	}

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

		dis[i]=-9999999;

		path[0].push_back(edge(i,0));

	}

	if(spfa(0))printf("No");

	else printf("Yes");

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 6.306954307933873x):
#include<bits/stdc++.h>

using namespace std;



typedef long long lint;

typedef pair<int, int> P;

#define REP(i, x, n) for(lint i = x ; i < n ; i++)

#define rep(i, n) REP(i, 0, n)

#define repr(i, n) for(lint i = n - 1 ; i >= 0 ; i--)

#define SORT(c) sort((c).begin(), (c).end())



const int IINF = 1e9 + 10;

const lint LLINF = (lint)1e18 + 10;

const lint MOD = (lint)1e9 + 7;

const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};



struct weightedUnionFind{



    vector<int> par, rank, wei;



    void init(int n){

        par.resize(n);

        rank.resize(n, 0);

        wei.resize(n, 0);

        rep(i, n){

            par[i] = i;

        }

        return;

    }



    int root(int x){

        if(par[x] == x){

            return x;

        }else{

            int r = root(par[x]);

            wei[x] += wei[par[x]];

            return par[x] = r;

        }

    }



    bool unite(int x, int y, int w){

        w = -w;

        w += weight(x);

        w -= weight(y);

        int rx = root(x);

        int ry = root(y);

        if(rx == ry){

            return false;

        }

        if(rank[rx] < rank[ry]){

            swap(rx, ry);

            w = -w;

        }

        if(rank[rx] == rank[ry]){

            rank[rx]++;

        }

        par[ry] = rx;

        wei[ry] = w;

        return true;

    }



    bool same(int x, int y){

        return root(x) == root(y);

    }



    int weight(int x){

        root(x);

        return wei[x];

    }



    int diff(int x, int y){

        return weight(x) - weight(y);

    }



};



int main(){

    int n, m;

    cin >> n >> m;

    weightedUnionFind uf;

    uf.init(n);

    bool flag = true;

    rep(i, m){

        int l, r, d;

        cin >> l >> r >> d;

        l--;

        r--;

        if(uf.same(l, r)){

            if(uf.diff(l, r) != d){

                flag = false;

                break;

            }

        }else{

            uf.unite(l, r, d);

        }

    }

    if(flag){

        cout << "Yes" << endl;

    }else{

        cout << "No" << endl;

    }

    return 0;

}