stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int n,m,dis[200001],l,r,d;

bool Error,f[200001];

struct edge {

	int to,cost;

	edge(int a=0,int b=0) {

		to=a;

		cost=b;

	}

};

vector<edge> path[200001];

void spfa(int x) {

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

		edge e=path[x][i];

		if(f[e.to])

			if(e.cost+dis[x]!=dis[e.to]) {

				Error=true;

				return;

			} else continue;

		f[e.to]=true;

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

		spfa(e.to);

		if(Error) return;

	}

}

int main() {

	cin>>n>>m;

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

		scanf("%d%d%d",&l,&r,&d);

		path[l].push_back(edge(r,d));

		path[r].push_back(edge(l,-d));

	}

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

		if(!f[i]) {

			spfa(i);

			if(Error) break;

		}

	}

	if(!Error) printf("Yes");

	else printf("No");

	return 0;

}

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

}
// 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: 1.7452958511187595x):
#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;

}
// 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: 10.006998354354565x):
#include<cstdio>

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	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: 18.31835388936378x):
#include<cstdio>

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	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: 33.19057213800161x):
#include<cstdio>

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	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: 9.350449790369195x):
#include<cstdio>

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	return 0;

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

using namespace std;

int n,m,dis[200001],l,r,d;

bool Error,f[200001];

struct edge {

	int to,cost;

	edge(int a=0,int b=0) {

		to=a;

		cost=b;

	}

};

vector<edge> path[200001];

void spfa(int x) {

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

		edge e=path[x][i];

		if(f[e.to])

			if(e.cost+dis[x]!=dis[e.to]) {

				Error=true;

				return;

			} else continue;

		f[e.to]=true;

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

		spfa(e.to);

		if(Error) return;

	}

}

int main() {

	cin>>n>>m;

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

		scanf("%d%d%d",&l,&r,&d);

		path[l].push_back(edge(r,d));

		path[r].push_back(edge(l,-d));

	}

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

		if(!f[i]) {

			spfa(i);

			if(Error) break;

		}

	}

	if(!Error) printf("Yes");

	else printf("No");

	return 0;

}

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

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	return 0;

}
// 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: 31.93031592903372x):
#include<cstdio>

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	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: 18.295073530694484x):
#include<cstdio>

#include<algorithm>

#define int long long

using namespace std;

const int maxN=1e6 + 100;

struct Node

{

	int to,value,next;

}edge[maxN*2+1];

int n,m,head[maxN+1],tot,dis[maxN+1];

bool col[maxN+1];

int maxT=-1e15,minT=1e15,ans=-1e15;

void add(int x,int y,int t)

{

	tot++;

	edge[tot].to=y;

	edge[tot].value=t;

	edge[tot].next=head[x];

	head[x]=tot;

}

bool dfs(int x)

{

	maxT=max(maxT,dis[x]);

	minT=min(minT,dis[x]);

	bool flag=true;

	col[x]=true;

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

		if(!col[edge[i].to]) dis[edge[i].to]=dis[x]+edge[i].value,flag=(flag&&dfs(edge[i].to));

		else if(dis[x]+edge[i].value!=dis[edge[i].to]) flag=false;

	return flag;

}

#undef int

int main()

#define int long long

{

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

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

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

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

	{

		int x,y,t;

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

		add(x,y,t); add(y,x,-t);

	}

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

		if(!col[i])

		{

			maxT=-1e18,minT=1e18;

			if(!dfs(i))

			{

				printf("No");

				return 0;

			}

			ans=max(ans,maxT-minT);

		}

	printf("Yes");

	fclose(stdin);

	fclose(stdout);

	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: 1.2444995035846886x):
#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;

}