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

using namespace std;

#define N 100005

#define M 200005

#define INF 0x3f3f3f3f

#define set(a,v) memset(a,v,sizeof(a))

int n,m,a[N],dst[N];bool ext[N],vs[N],fl[N];

int cntE,hd[N];struct Edge {int v,w,nxt;}e[M<<1];

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

{

	e[++cntE]=(Edge) {v,w,hd[u]};

	hd[u]=cntE;

}

bool SPFA(int u)

{

	vs[u]=fl[u]=1;

	for(int i=hd[u],v,w;~i;i=e[i].nxt)

	{

		v=e[i].v;

		w=e[i].w;

		if(dst[u]+w<dst[v])

		{

			if(vs[v]) return 0;

			dst[v]=dst[u]+w;

			if(!SPFA(v)) return 0;

		}

	}

	vs[u]=0;

	return 1;

}

int main()

{

	set(hd,-1);

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

	for(int i=1,F[3];i<=m;++i)

	{

		scanf("%d %d %d",&F[0],&F[1],&F[2]);

		ext[F[0]]=ext[F[1]]=1;

		addE(F[0],F[1],F[2]);

		addE(F[1],F[0],-F[2]);

	}

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

		if(ext[i] && !fl[i])

		{

			set(dst,INF);

			dst[i]=0;

			if(!SPFA(i))

			{

				puts("No");

				return 0;

			}

		}

	puts("Yes");

	return 0;

}

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

}