#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template <typename T>
using VT = vector<T>;
template <typename T>
inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;
class UnionFind {
 private:
  std::vector<int> uni;
  int size_;
  const void check(const int n) const {
    if (this->group_size() < 0) {
      assert(false);
    }
    if (!(0 <= n && n < this->all_size())) {
      assert(false);
    }
  }

 public:
  UnionFind() : size_(-1) {}
  UnionFind(const int n) : uni(n, -1), size_(n) { this->check(n - 1); }
  bool same(const int a, const int b) {
    this->check(a);
    this->check(b);
    return this->find(a) == this->find(b);
  }
  int find(const int a) {
    this->check(a);
    return this->uni[a] < 0 ? a : this->uni[a] = this->find(this->uni[a]);
  }
  bool unite(int a, int b) {
    a = this->find(a);
    b = this->find(b);
    if (a == b) {
      return false;
    }
    this->size_--;
    if (this->uni[a] > this->uni[b]) {
      std::swap(a, b);
    }
    this->uni[a] += this->uni[b];
    this->uni[b] = a;
    return true;
  }
  const int group_size() const { return this->size_; }
  const int all_size() const { return this->uni.size(); }
  const int size(const int a) {
    this->check(a);
    return -this->uni[this->find(a)];
  }
};
const int MAX = 2e5 + 10;
int N, M;
int L[MAX], R[MAX], D[MAX];
LL x[MAX];
UnionFind uf(MAX);
vector<int> vec[MAX];
int main(void) {
  scanf("%d%d", &N, &M);
  for (int(i) = 0; (i) < (M); (i)++) {
    scanf("%d%d%d", L + i, R + i, D + i);
    L[i]--;
    R[i]--;
  }
  memset(x, -1, sizeof(x));
  for (int(i) = 0; (i) < (M); (i)++) {
    uf.unite(L[i], R[i]);
  }
  bool ok = true;
  for (int(i) = 0; (i) < (M); (i)++) {
    if (x[L[i]] == -1 && x[R[i]] == -1) {
      x[L[i]] = 0;
      x[R[i]] = x[L[i]] + D[i];
    } else if (x[L[i]] == -1) {
      x[L[i]] = x[R[i]] - D[i];
    } else if (x[R[i]] == -1) {
      x[R[i]] = x[L[i]] + D[i];
    }
    if (x[R[i]] != x[L[i]] + D[i]) {
      ok = false;
    }
  }
  for (int(i) = 0; (i) < (N); (i)++) {
    vec[uf.find(i)].emplace_back(i);
  }
  for (int(i) = 0; (i) < (N); (i)++) {
    if (vec[i].size()) {
      LL mi = 0;
      for (auto &&e : (vec[i])) {
        chmin(mi, x[e]);
      }
      for (auto &&e : (vec[i])) {
        x[e] += -mi;
      }
      LL ma = INF;
      for (auto &&e : (vec[i])) {
        chmax(mi, x[e]);
      }
      for (auto &&e : (vec[i])) {
        x[e] -= ma - INF;
      }
      for (auto &&e : (vec[i])) {
        ok &= (0 <= x[e] && x[e] <= INF);
      }
    }
  }
  cout << (ok ? "Yes" : "No") << endl;
}
