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];



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

#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<pair<ll, ll>>> G;

vl visited;

vl d(MAX_N);

bool ok = true;



void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

            return;

        }

        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);

    }

    return;

}



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);

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

#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<pair<ll, ll>>> G;

vl visited;

vl d(MAX_N);

bool ok = true;



void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

            return;

        }

        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);

    }

    return;

}



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);

    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: 3.567936299703482x):
#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(MAX_N);

bool ok = true;



void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

            return;

        }

        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);

    }

    return;

}



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);

    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: 3.567936299703482x):
#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(MAX_N);

bool ok = true;



void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

            return;

        }

        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);

    }

    return;

}



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);

    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: 4.130887254350087x):
#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(MAX_N);

bool ok = true;



void dfs(ll v, ll dist) {

    if(visited[v]) {

        if(d[v] != dist) {

            ok = false;

            return;

        }

        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);

    }

    return;

}



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);

    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.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;

}