// Slower C++ solution:
/*************************************************

 *************************************************

 *************************************************

 *** _________________  |            |  |     /***

 ***         |          |            |  |    / ***

 ***         |          |            |  |   /  ***

 ***         |          |            |  |  /   ***

 ***         |          |            |  | /    ***

 ***         |          |____________|  |/  en ***

 ***         |          |            |  |\     ***

 ***         |          |            |  | \    ***

 *** _____   |          |            |  |  \   ***

 ***   |     |          |            |  |   \  ***

 ***   \     /          |            |  |    \ ***

 ***    \___/           |            |  |     \***

 *************************************************

 *************Written by: JiangHaoKai*************

 *************************************************/



//#include <bits/stdc++.h>

#include <cassert>

#include <cctype>

#include <cerrno>

#include <cfloat>

#include <climits>

#include <clocale>

#include <cmath>

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <ccomplex>

#include <cfenv>

#include <cinttypes>

#include <cstdalign>

#include <cstdbool>

#include <cstdint>

#include <ctgmath>

#include <cwchar>

#include <cwctype>

#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <fstream>

#include <functional>

#include <iomanip>

#include <iostream>

#include <limits>

#include <list>

#include <locale>

#include <map>

#include <memory>

#include <numeric>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <string>

#include <typeinfo>

#include <valarray>

#include <vector>

#include <array>

#include <atomic>

#include <chrono>

#include <condition_variable>

#include <forward_list>

#include <future>

#include <mutex>

#include <random>

#include <ratio>

#include <regex>

#include <scoped_allocator>

#include <system_error>

#include <thread>

#include <tuple>

#include <typeindex>

#include <unordered_map>

#include <unordered_set>

//#include <windows.h>

using namespace std;



typedef long long ll;

typedef unsigned int ui;

typedef unsigned long long ull;

typedef float fl;

typedef double ld;

typedef pair<int,int> pii;

#define ui(n) ((unsigned int)(n))

#define ll(n) ((long long)(n))

#define ull(n) ((unsigned long long)(n))

#define fl(n) ((float)(n))

#define ld(n) ((double)(n))

#define char(n) ((char)(n))

#define Bool(n) ((bool)(n))

#define fixpoint(n) fixed<<setprecision(n)

const int INF=1e9+7;

const ll LINF=1e18;

#define PI 3.1415926535897932384626433832795028841971

#define MP make_pair

#define MT make_tuple

#define All(a) (a).begin(),(a).end()

#define pall(a) (a).rbegin(),(a).rend()

#define mod 1000000007

#define sz(a) ((int)(a).size())

#define rep(i,n) for(int i=0;i<n;i++)

#define rep1(i,n) for(int i=1;i<=n;i++)

#define repa(i,a,n) for(int i=a;i<n;i++)

#define repd(i,n) for(int i=n-1;i>=0;i--)

#define FOR(i,a,n,step) for(int i=a;i<n;i+=step)

#define repv(itr,v) for(__typeof((v).begin()) itr=(v).begin();itr!=(v).end();itr++)

#define repV(i,v) for(auto i:v)

#define repE(i,v) for(auto &i:v)

#define MS(x,y) memset(x,y,sizeof(x))

#define sqr(x) ((x)*(x))

#define filein(x) freopen(x,"r",stdin)

#define fileout(x) freopen(x,"w",stdout)

#define fileout2(filename,name) ofstream name(filename,ios::out)

#define filein2(filename,name) ifstream name(filename,ios::in)

#define file(filename,name) fstream name(filename,ios::in|ios::out)

#define Pause system("pause")

#define Cls system("cls")

#define fs first

#define sc second

#define PC(x) putchar(x)

#define GC(x) x=getchar()

#define Endl PC('\n')



inline int READ()

{

    int X=0,w=0;char ch=0;while(!isdigit(ch)){w|=ch=='-';ch=getchar();}while(isdigit(ch))X=(X<<3)+(X<<1)+(ch^48),ch=getchar();

	return w?-X:X;

}

inline void WRITE(int x){if(x<0)putchar('-'),x=-x;if(x>9)WRITE(x/10);putchar(x%10+'0');}

inline void WRITEend(int x){WRITE(x);exit(0);}



inline ll powmod(ll a,ll b){ll res=1;a%=mod;assert(b>=0);for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}

inline ll gcdll(ll a,ll b){return b?gcdll(b,a%b):a;}

inline string itoa(ll a){string res="";while(a>0)res+=(a%10+'0'),a/=10;reverse(All(res));return res==""?"0":res;}

inline ll atoi(string s){ll res=0;repV(i,s)res=res*10+i-'0';return res;}

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

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

/**************************************************************Begin***************************************************************/

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

vector<pair<int,int> > e[100010];

ll pos[100010];



int main()

{

	rep(i,100000) pos[i]=INF;

	

	while(m--)

	{

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

		l--;r--;

		e[l].push_back(MP(r,d));

		e[r].push_back(MP(l,-d));

	}

	

	rep(i,n) if(pos[i]==INF)

	{

		queue<int> q;q.push(i);pos[i]=0;

		while(!q.empty())

		{

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

			repV(j,e[x])

			{

				int to=j.fs,c=j.sc;

				if(pos[to]==INF)

				{

					pos[to]=pos[x]+c;

					q.push(to);

				}

				else if(pos[to]!=pos[x]+c)

				{

					puts("No");

					exit(0);

				}

			}

		}

	}

	

	puts("Yes");



	return 0;

}

/***************************************************************End****************************************************************/


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

#define int long long

#define x first

#define y second





using namespace std;



vector<int> color(1e5 + 1);



int get_color(int x){

    //cout << x << endl;

    if(x == color[x]){

        return x;

    }

    return color[x] =  get_color(color[x]);

}



void update(int x, int y){

    if(get_color(x) != get_color(y)){

        //cout << x << ' ' << y << endl;

        color[get_color(x)] = get_color(y);

    }

}



bool comp(vector<int> x, vector<int> y){

    return min(x[0], x[1]) < min(y[0], y[1]);

}



void check(vector<int> sv, vector<vector<int> > og){

    int n = sv.size();

    int mi = 0, ma = 0;

    if(og.size() == 0){

        return;

    }

    map<int, int> c;

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

        c[sv[i]] =i;

    }

    vector<int> used(n,  0), x(n, 0);

    used[0] = 1;

    vector<vector<vector<int> > > dop(n);

    for(auto it : og){

        dop[c[it[0]]].push_back(it);

        dop[c[it[1]]].push_back(it);

    }

    queue<vector<int> > d;

    for(auto it : dop[0]){

        d.push(it);

    }

    while(!d.empty()){

        auto it = d.front();

        d.pop();

        int t = c[it[0]], t1 = c[it[1]];

        if(used[t] == 0){

            swap(t, t1);

            it[2] = -it[2];

        }

        if(used[t1] == 0){

            for(auto it1 : dop[t1]){

                if(it1 != it)

                d.push(it1);

            }

        }

        if(used[t1] == 1 && x[t1] != x[t] + it[2]){

            cout << "No";

            exit(0);

        }

        if(used[t] == 0){

            exit(-1);

        }

        used[t1] = 1;

        x[t1] = x[t] + it[2];

    }

    for(auto it : x){

        mi = min(it, mi);

        ma = max(it, ma);

    }

    if(ma - mi > 1e9){

        cout << "No";

        exit(0);

    }

}



void solve(){

    int n, q;

    cin >> n >> q;

    vector<vector<int> > e(q);

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

        color[i] = i;

    }

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

        int l, r, d;

        cin >> l >> r >> d;

        e[i] = {--l, --r, d};

        update(l, r);

        //cout << color[0] << ' ' << color[1] <<' ' << color[2] << endl;

    }

    vector<vector<int> > sv(n);

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

        sv[get_color(i)].push_back(i);

    }

   vector<vector<vector<int> > > og(n);

   for(auto it : e){

        og[get_color(it[0])].push_back(it);

   }

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

    sort(og[i].begin(), og[i].end(), comp);

    //out << "rhgingk" <<  endl;

    check(sv[i], og[i]);

   }

   cout << "Yes";

}





signed main() {

    ios::sync_with_stdio(0);

    cin.tie(0);

    int test = 1;

    //freopen("output.txt", "w", stdout);

    //freopen("input.txt", "r", stdin);

    //

    //cin >> test;

    while(test--){

        solve();

    }

}