// Slower C++ solution:
#include <iostream>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <bitset>

#include <algorithm>

#include <cstdio>

#include <time.h>

#include <queue>

#include <set>

#include <map>

#include <stack>

#include <math.h>

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

#define ll long long

#define int64 long long

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

#define ull unsigned long long

#define pb push_back

#define INF 0x7f7f7f7f

#define lson l, mid, rt<<1

#define rson mid+1, r, rt<<1|1

#define pi 3.141592653589793238462

#define stdio std::ios::sync_with_stdio(false)

#define zero(x) (((x)>0?(x):-(x))<eps)



using namespace std;



inline bool nextDouble(double &num) {

    char in;

    double Dec = 0.1;

    bool IsN = false, IsD = false;

    in = getchar();

    if (in == EOF) return false;

    while (in != '-' && in != '.' && (in < '0' || in > '9'))

        in = getchar();

    if (in == '-') {

        IsN = true;

        num = 0;

    } else if (in == '.') {

        IsD = true;

        num = 0;

    } else num = in - '0';

    if (!IsD) {

        while (in = getchar(), in >= '0' && in <= '9') {

            num *= 10;

            num += in - '0';

        }

    }

    if (in != '.') {

        if (IsN) num = -num;

        return true;

    } else {

        while (in = getchar(), in >= '0' && in <= '9') {

            num += Dec * (in - '0');

            Dec *= 0.1;

        }

    }

    if (IsN) num = -num;

    return true;

}

inline bool nextLongDouble(long double &num) {

    char in;

    long double Dec = 0.1;

    bool IsN = false, IsD = false;

    in = getchar();

    if (in == EOF) return false;

    while (in != '-' && in != '.' && (in < '0' || in > '9'))

        in = getchar();

    if (in == '-') {

        IsN = true;

        num = 0;

    } else if (in == '.') {

        IsD = true;

        num = 0;

    } else num = in - '0';

    if (!IsD) {

        while (in = getchar(), in >= '0' && in <= '9') {

            num *= 10;

            num += in - '0';

        }

    }

    if (in != '.') {

        if (IsN) num = -num;

        return true;

    } else {

        while (in = getchar(), in >= '0' && in <= '9') {

            num += Dec * (in - '0');

            Dec *= 0.1;

        }

    }

    if (IsN) num = -num;

    return true;

}

inline bool nextInt(int &num) {

    char in;

    bool IsN = false;

    in = getchar();

    if (in == EOF) return false;

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

    if (in == '-') {

        IsN = true;

        num = 0;

    } else num = in - '0';

    while (in = getchar(), in >= '0' && in <= '9') {

        num *= 10, num += in - '0';

    }

    if (IsN) num = -num;

    return true;

}

inline bool nextLong(ll &num) {

    char in;

    bool IsN = false;

    in = getchar();

    if (in == EOF) return false;

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

    if (in == '-') {

        IsN = true;

        num = 0;

    } else num = in - '0';

    while (in = getchar(), in >= '0' && in <= '9') {

        num *= 10, num += in - '0';

    }

    if (IsN) num = -num;

    return true;

}

inline bool blank(char ch) {

    return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';

}

inline void read(char *s) {

    char ch = getchar();

    for (; blank(ch); ch = getchar());

    for (; !blank(ch); ch = getchar()) * s++ = ch;

    *s = 0;

}

const int maxn = 1e5 + 5;

const int maxm = 2e6 + 5;

const int mod =  1e9;

const int seed = 10007;

const double eps = 1e-6;

int n, m;

typedef pair<int, int> dist;



vector<dist> g[maxn];



int dis[maxn];

bool vis[maxn];

bool dfs(int x) {

    vis[x] = false;

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

        int v = g[x][i].first;

        int w = g[x][i].second;

        if (dis[v] == -1) {

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

            if (!dfs(v)) return false;

        } else {

            if (dis[v] == dis[x] + w) {

                continue;

            } else {

                return false;

            }

        }

    }

    return true;

}



int main() {

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

    int u, v, w;

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

        scanf("%d%d%d", &u, &v, &w);

        g[u].pb(dist(v, w));

    }

    mem(vis, true);

    bool flag = true;

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

        if (vis[i]) {

            mem(dis, -1);

            flag = dfs(i);

            if (!flag) break;

        }

    }

    if (flag) printf("Yes\n");

    else printf("No\n");

    return 0;

}

/*

for(x:i) if(ans[x][j]=0) ans[i][j]=1

for(x:i) if(ans[x][j]=1)

*/


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

using namespace std;

const int N = 1e5 + 25, M = 1e6 + 25, oo = 1e9+7, mxmsk = 1 << 16;

const long long OO = 1e18+25;

    

#define f first

#define s second

    

int n,m,l,r,d, dis[N], vis[N], v=1;

vector <pair<int, int>> g[N];

stack <int> st;

int dfs(int from)

{

    vis[from] = v;

    for(auto pa : g[from])

    {

        if(vis[pa.f] != v)

        {

            dis[pa.f] = dis[from] + pa.s;

            if(dfs(pa.f) == -1)

            {

                return -1;

            }

        }else if(dis[pa.f] != dis[from] + pa.s)

        {

            return -1;

        }

    }

    return 1;

}



void dfs1(int from)

{

    vis[from] = v;

    for(auto pa: g[from])

    {

        if(vis[pa.f] != v)

        {

            dfs1(pa.f);

        }

    }

}



int main() {

    cin >> n >> m;

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

    {

        cin >> l >> r >> d;

        g[l].push_back({r,d});

    }

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

    {

        if(vis[i] != v) 

        {

            st.push(i);

            dfs1(i);

        }

    }

    v++;

    while(!st.empty())

    {

        int i = st.top();

        if(vis[i] != v)

        {

            for(auto pa : g[i])

            {

                if(vis[pa.f] == v)

                {

                    dis[i] = dis[pa.f] - pa.s;

                    break;

                }

            }

            if(dfs(i) == -1)

            {

               cout << "No";

                return 0;

            }

        }

        st.pop();

    }

    cout << "Yes";

    return 0;

}