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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;



struct edge {

    int to;

    int weight;

};



vector<edge> G[200010];

bool visit[100010];

int d[100010];



bool dfs(int v, int dist) {



    if(visit[v]) {

        if(d[v] != dist) {

            return true;

        }

        else {

            return false;

        }

    }



    visit[v] = true;

    d[v] = dist;

    rep(i, G[v].size()) {

        if(dfs(G[v][i].to, d[v] + G[v][i].weight)) {

            return true;

        }

    }



    return false;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].push_back({R,D});

        G[R].push_back({L,-D});

    }



    rep(i, n) {

        if(!visit[i] && dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef vector<vector<pair<ll, ll>>> vvpll;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100010;

 

vvpll G;

vl visited;

vl d;

bool ok = true;

 

void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

        }

        return;

    }

    visited[v] = 1;

    d[v] = dist;

    for(auto p : G[v]) {

        ll u = p.first;

        ll cost = p.second;

        dfs(u, d[v] + cost);

    }

}

 

int main() {

    ll n, m;

    cin >> n >> m;    

 

    G.resize(n);

    rep(i, m) {

        ll L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].pb(make_pair(R, D));

        G[R].pb(make_pair(L, -D));

    }

 

    visited.resize(n);

    d.resize(n);

    rep(v, n) {

        if(!visited[v]) {

            dfs(v, 0);

        }

    }

 

    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }

    

    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;



struct edge {

    int to;

    int weight;

};



vector<edge> G[200010];

bool visit[100010];

int d[100010];



int dfs(int v, int dist) {



    if(visit[v]) {

        if(d[v] != dist) {

            return 1;

        }

        else {

            return 0;

        }

    }



    visit[v] = true;

    d[v] = dist;

    rep(i, G[v].size()) {

        if(dfs(G[v][i].to, d[v] + G[v][i].weight)) {

            return 1;

        }

    }



    return 0;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].push_back({R,D});

        G[R].push_back({L,-D});

    }



    rep(i, n) {

        if(!visit[i] && dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef vector<vector<pair<ll, ll>>> vvpll;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100010;

 

vvpll G;

vl visited;

vl d;

bool ok = true;

 

void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

        }

        return;

    }

    visited[v] = 1;

    d[v] = dist;

    for(auto p : G[v]) {

        ll u = p.first;

        ll cost = p.second;

        dfs(u, d[v] + cost);

    }

}

 

int main() {

    ll n, m;

    cin >> n >> m;    

 

    G.resize(n);

    rep(i, m) {

        ll L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].pb(make_pair(R, D));

        G[R].pb(make_pair(L, -D));

    }

 

    visited.resize(n);

    d.resize(n);

    rep(v, n) {

        if(!visited[v]) {

            dfs(v, 0);

        }

    }

 

    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }

    

    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

using Graph = vector<vector<int>>;

typedef long long ll;

const ll mod = 1000000007;

const int MAX_N = 100010;



Graph to(MAX_N), cost(MAX_N);

vector<int> visit(MAX_N), d(MAX_N);



bool dfs(int v, int dist) {

 

    if(visit[v]) {



        if(d[v] != dist) {

            return false;

        }

        

        return true;

    }



    visit[v] = 1;

    d[v] = dist;

    rep(u, to[v].size()) {

        if( !dfs(to[v][u], d[v] + cost[v][u]) ) {

            return false;

        }

    }

 

    return true;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, w;

        cin >> L >> R >> w;

        L--;  R--;

        to[L].push_back(R);

        to[R].push_back(L);

        cost[L].push_back(w);

        cost[R].push_back(-w);

    }



    rep(i, n) {

        if(!visit[i] && !dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef vector<vector<pair<ll, ll>>> vvpll;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100010;

 

vvpll G;

vl visited;

vl d;

bool ok = true;

 

void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

        }

        return;

    }

    visited[v] = 1;

    d[v] = dist;

    for(auto p : G[v]) {

        ll u = p.first;

        ll cost = p.second;

        dfs(u, d[v] + cost);

    }

}

 

int main() {

    ll n, m;

    cin >> n >> m;    

 

    G.resize(n);

    rep(i, m) {

        ll L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].pb(make_pair(R, D));

        G[R].pb(make_pair(L, -D));

    }

 

    visited.resize(n);

    d.resize(n);

    rep(v, n) {

        if(!visited[v]) {

            dfs(v, 0);

        }

    }

 

    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }

    

    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;



struct edge {

    int to;

    int weight;

};



vector<edge> G[200010];

bool visit[100010];

int d[100010];



bool dfs(int v, int dist) {



    if(visit[v]) {

        if(d[v] != dist) {

            return true;

        }

        else {

            return false;

        }

    }



    visit[v] = true;

    d[v] = dist;

    rep(i, G[v].size()) {

        if(dfs(G[v][i].to, d[v] + G[v][i].weight)) {

            return true;

        }

    }



    return false;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].push_back({R,D});

        G[R].push_back({L,-D});

    }



    rep(i, n) {

        if(!visit[i] && dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <tuple>

#include <numeric>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef pair<ll, ll> P;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100000;



vector<vector<P>> G;

vl visited;  // visted[v] : 頂点vを訪問済みなら1

vl height;  // height[v] : 頂点vの高さ

bool ok = true;  // 条件が矛盾していないならtrue



void dfs(ll v, ll h = 0) {  // いまいる頂点v、vの高さ

    // 行きの処理はこのへんに書く

    if(visited[v]) {

        if(height[v] != h) {

            ok = false;

        }

        return;

    }

    visited[v] = 1;

    height[v] = h;

    for(auto p : G[v]) { 

        ll u = p.first;

        ll cost = p.second;

        dfs(u, h + cost);

        // 帰りの処理はこのへんに書く

    }

}



int main() {

    ll n, m;

    cin >> n >> m;    

    

    G.resize(n);

    rep(i, m) {

        ll a, b, cost;

        cin >> a >> b >> cost;

        a--;  b--;

        G[a].pb(make_pair(b, cost));

        G[b].pb(make_pair(a, -cost));

    }

    

    height.resize(n);

    visited.resize(n);

    rep(v, n) {

        if(visited[v]) {

            continue;

        }

        dfs(v);

    }



    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }



    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;



struct edge {

    int to;

    int weight;

};



vector<edge> G[200010];

bool visit[100010];

int d[100010];



int dfs(int v, int dist) {



    if(visit[v]) {

        if(d[v] != dist) {

            return 1;

        }

        else {

            return 0;

        }

    }



    visit[v] = true;

    d[v] = dist;

    rep(i, G[v].size()) {

        if(dfs(G[v][i].to, d[v] + G[v][i].weight)) {

            return 1;

        }

    }



    return 0;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].push_back({R,D});

        G[R].push_back({L,-D});

    }



    rep(i, n) {

        if(!visit[i] && dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <tuple>

#include <numeric>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef pair<ll, ll> P;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100000;



vector<vector<P>> G;

vl visited;  // visted[v] : 頂点vを訪問済みなら1

vl height;  // height[v] : 頂点vの高さ

bool ok = true;  // 条件が矛盾していないならtrue



void dfs(ll v, ll h = 0) {  // いまいる頂点v、vの高さ

    // 行きの処理はこのへんに書く

    if(visited[v]) {

        if(height[v] != h) {

            ok = false;

        }

        return;

    }

    visited[v] = 1;

    height[v] = h;

    for(auto p : G[v]) { 

        ll u = p.first;

        ll cost = p.second;

        dfs(u, h + cost);

        // 帰りの処理はこのへんに書く

    }

}



int main() {

    ll n, m;

    cin >> n >> m;    

    

    G.resize(n);

    rep(i, m) {

        ll a, b, cost;

        cin >> a >> b >> cost;

        a--;  b--;

        G[a].pb(make_pair(b, cost));

        G[b].pb(make_pair(a, -cost));

    }

    

    height.resize(n);

    visited.resize(n);

    rep(v, n) {

        if(visited[v]) {

            continue;

        }

        dfs(v);

    }



    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }



    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

using Graph = vector<vector<int>>;

typedef long long ll;

const ll mod = 1000000007;

const int MAX_N = 100010;



Graph to(MAX_N), cost(MAX_N);

vector<int> visit(MAX_N), d(MAX_N);



bool dfs(int v, int dist) {

 

    if(visit[v]) {



        if(d[v] != dist) {

            return false;

        }

        

        return true;

    }



    visit[v] = 1;

    d[v] = dist;

    rep(u, to[v].size()) {

        if( !dfs(to[v][u], d[v] + cost[v][u]) ) {

            return false;

        }

    }

 

    return true;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, w;

        cin >> L >> R >> w;

        L--;  R--;

        to[L].push_back(R);

        to[R].push_back(L);

        cost[L].push_back(w);

        cost[R].push_back(-w);

    }



    rep(i, n) {

        if(!visit[i] && !dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <tuple>

#include <numeric>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef pair<ll, ll> P;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100000;



vector<vector<P>> G;

vl visited;  // visted[v] : 頂点vを訪問済みなら1

vl height;  // height[v] : 頂点vの高さ

bool ok = true;  // 条件が矛盾していないならtrue



void dfs(ll v, ll h = 0) {  // いまいる頂点v、vの高さ

    // 行きの処理はこのへんに書く

    if(visited[v]) {

        if(height[v] != h) {

            ok = false;

        }

        return;

    }

    visited[v] = 1;

    height[v] = h;

    for(auto p : G[v]) { 

        ll u = p.first;

        ll cost = p.second;

        dfs(u, h + cost);

        // 帰りの処理はこのへんに書く

    }

}



int main() {

    ll n, m;

    cin >> n >> m;    

    

    G.resize(n);

    rep(i, m) {

        ll a, b, cost;

        cin >> a >> b >> cost;

        a--;  b--;

        G[a].pb(make_pair(b, cost));

        G[b].pb(make_pair(a, -cost));

    }

    

    height.resize(n);

    visited.resize(n);

    rep(v, n) {

        if(visited[v]) {

            continue;

        }

        dfs(v);

    }



    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }



    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;



struct edge {

    int to;

    int weight;

};



vector<edge> G[200010];

bool visit[100010];

int d[100010];



bool dfs(int v, int dist) {



    if(visit[v]) {

        if(d[v] != dist) {

            return true;

        }

        else {

            return false;

        }

    }



    visit[v] = true;

    d[v] = dist;

    rep(i, G[v].size()) {

        if(dfs(G[v][i].to, d[v] + G[v][i].weight)) {

            return true;

        }

    }



    return false;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].push_back({R,D});

        G[R].push_back({L,-D});

    }



    rep(i, n) {

        if(!visit[i] && dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <tuple>

#include <numeric>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef pair<ll, ll> P;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100010;



vector<vector<P>> G;

vl height;

bool ok = true;



void dfs(ll v, ll h) {

    // 行きの処理はこのへんに書く

    if(ok == false) {

        return;

    }

    if(height[v] == -INF) {

        height[v] = h;

    }

    else {

        if(height[v] != h) {

            ok = false;

        }

        return;

    }

    for(auto p : G[v]) { 

        ll u = p.first;

        ll cost = p.second;

        dfs(u, h + cost);

        // 帰りの処理はこのへんに書く

    }

}



int main() {

    ll n, m;

    cin >> n >> m;    

    

    G.resize(n);

    rep(i, m) {

        ll a, b, c;

        cin >> a >> b >> c;

        a--;  b--;

        G[a].pb(make_pair(b, c));

        G[b].pb(make_pair(a, -c));

    }



    height.assign(n, -INF);

    rep(v, n) {

        if(height[v] == -INF) {

            dfs(v, 0);

        }

    }



    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }



    re0;

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

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

using namespace std;

typedef long long ll;

const ll mod = 1000000007;



struct edge {

    int to;

    int weight;

};



vector<edge> G[200010];

bool visit[100010];

int d[100010];



int dfs(int v, int dist) {



    if(visit[v]) {

        if(d[v] != dist) {

            return 1;

        }

        else {

            return 0;

        }

    }



    visit[v] = true;

    d[v] = dist;

    rep(i, G[v].size()) {

        if(dfs(G[v][i].to, d[v] + G[v][i].weight)) {

            return 1;

        }

    }



    return 0;

}



int main() {

    int n, m;

    cin >> n >> m;



    rep(i, m) {

        int L, R, D;

        cin >> L >> R >> D;

        L--;  R--;

        G[L].push_back({R,D});

        G[R].push_back({L,-D});

    }



    rep(i, n) {

        if(!visit[i] && dfs(i, 0)) {

            cout << "No" << endl;

            return 0;

        }

    }

    

    cout << "Yes" << endl;

    return 0;

}

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

#include <cstdio>

#include <string>

#include <algorithm>

#include <utility>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <map>

#include <tuple>

#include <numeric>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<ll> vl;

typedef vector<vector<ll>> vvl;

typedef pair<ll, ll> P;

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

#define exrep(i, a, b) for(ll i = a; i <= b; i++)

#define out(x) cout << x << endl

#define exout(x) printf("%.10f\n", x)

#define chmax(x, y) x = max(x, y)

#define chmin(x, y) x = min(x, y)

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

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

#define pb push_back

#define re0 return 0

const ll mod = 1000000007;

const ll INF = 1e16;

const ll MAX_N = 100010;



vector<vector<P>> G;

vl height;

bool ok = true;



void dfs(ll v, ll h) {

    // 行きの処理はこのへんに書く

    if(ok == false) {

        return;

    }

    if(height[v] == -INF) {

        height[v] = h;

    }

    else {

        if(height[v] != h) {

            ok = false;

        }

        return;

    }

    for(auto p : G[v]) { 

        ll u = p.first;

        ll cost = p.second;

        dfs(u, h + cost);

        // 帰りの処理はこのへんに書く

    }

}



int main() {

    ll n, m;

    cin >> n >> m;    

    

    G.resize(n);

    rep(i, m) {

        ll a, b, c;

        cin >> a >> b >> c;

        a--;  b--;

        G[a].pb(make_pair(b, c));

        G[b].pb(make_pair(a, -c));

    }



    height.assign(n, -INF);

    rep(v, n) {

        if(height[v] == -INF) {

            dfs(v, 0);

        }

    }



    if(ok) {

        out("Yes");

    }

    else {

        out("No");

    }



    re0;

}