#include <bits/stdc++.h>
typedef std::pair<long long, long long> PLL;
typedef std::pair<int, int> PII;
const int INF = (int)1e9;
const long long MOD = (long long)1e9 + 7;
const long long LINF = (long long)4e18 + 20;
const long double PI = acos(-1.0);
const double EPS = 1e-9;
using namespace ::std;
template <class T>
inline T gcd(T a, T b) {
  return b ? gcd(b, a % b) : a;
}
template <class T>
inline T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
long long powMod(long long num, long long n, long long mod = (long long)MOD) {
  num %= mod;
  if (n == 0) {
    return (long long)1;
  }
  long long mul = num;
  long long ans = (long long)1;
  while (n) {
    if (n & 1) {
      ans = (ans * mul) % mod;
    }
    mul = (mul * mul) % mod;
    n >>= 1;
  }
  return ans;
}
long long mod_inverse(long long num, long long mod = MOD) {
  return powMod(num, MOD - 2, MOD);
}
template <class T>
vector<T> getDivisor(T n) {
  vector<T> v;
  for (int i = 1; i * i <= n; ++i) {
    if (n % i == 0) {
      v.push_back(i);
      if (i != n / i) {
        v.push_back(n / i);
      }
    }
  }
  sort(v.begin(), v.end());
  return v;
}
template <class T>
void UNIQUE(vector<T>& vec) {
  sort(vec.begin(), vec.end());
  vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
long long bitcount64(long long bits) {
  bits = (bits & 0x5555555555555555) + (bits >> 1 & 0x5555555555555555);
  bits = (bits & 0x3333333333333333) + (bits >> 2 & 0x3333333333333333);
  bits = (bits & 0x0f0f0f0f0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f0f0f0f0f);
  bits = (bits & 0x00ff00ff00ff00ff) + (bits >> 8 & 0x00ff00ff00ff00ff);
  bits = (bits & 0x0000ffff0000ffff) + (bits >> 16 & 0x0000ffff0000ffff);
  return (bits & 0x00000000ffffffff) + (bits >> 32 & 0x00000000ffffffff);
}
struct edge_base {
  int to;
  long long cost;
};
edge_base make_edge_base(int to, long long cost) {
  edge_base ret = {to, cost};
  return ret;
}
template <class T, class EDGE>
void dijkstra(int root, int V, vector<T>& dist, vector<int>& prev,
              vector<vector<EDGE> > G) {
  priority_queue<pair<T, int>, vector<pair<T, int> >, greater<pair<T, int> > >
      que;
  dist.assign(V, LINF);
  prev.assign(V, -1);
  dist[root] = 0;
  que.push(pair<T, int>(0, root));
  while (!que.empty()) {
    pair<T, int> p = que.top();
    que.pop();
    int v = p.second;
    if (dist[v] < p.first) continue;
    for (int i = 0; i < (int)G[v].size(); ++i) {
      EDGE e = G[v][i];
      if (dist[e.to] > dist[v] + e.cost) {
        dist[e.to] = dist[v] + e.cost;
        prev[e.to] = v;
        que.push(pair<T, int>(dist[e.to], e.to));
      }
    }
  }
}
vector<int> get_path(vector<int>& prev, int t) {
  vector<int> path;
  while (t != -1) {
    path.push_back(t);
    t = prev[t];
  }
  reverse(path.begin(), path.end());
  return path;
}
void warshall_floyd(vector<vector<long long> >& dist, int V,
                    const long long inf = LINF) {
  for (int k = 0; k < V; ++k) {
    for (int i = 0; i < V; ++i) {
      if (dist[i][k] >= inf) continue;
      for (int j = 0; j < V; ++j) {
        if (dist[k][j] >= inf) continue;
        dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
      }
    }
  }
}
namespace FLOW {
struct edge_flow : public edge_base {
  long long cap;
  int rev;
};
edge_flow make_edge_flow(int to, int cap, int rev, long long cost = 1) {
  edge_flow ret;
  ret.to = to;
  ret.cost = cost;
  ret.cap = cap;
  ret.rev = rev;
  return ret;
}
class Graph {
 public:
  int V;
  vector<vector<FLOW::edge_flow> > G;
  vector<long long> dist;
  vector<int> iter;
  vector<bool> used;
  void init(int v) {
    V = v;
    G.resize(V);
  }
  void reset() {
    iter.assign(V, 0);
    used.assign(V, false);
  }
  void add_edge(int from, int to, int cap) {
    G[from].push_back(FLOW::make_edge_flow(to, cap, G[to].size()));
    G[to].push_back(FLOW::make_edge_flow(from, 0, G[from].size() - 1));
  }

 private:
  void bfs(int s) {
    queue<int> que;
    dist = vector<long long>(V, -1);
    dist[s] = 0;
    que.push(s);
    while (!que.empty()) {
      int v = que.front();
      que.pop();
      for (int i = 0; i < (int)G[v].size(); ++i) {
        edge_flow& e = G[v][i];
        if (e.cap > 0 && dist[e.to] < 0) {
          dist[e.to] = dist[v] + 1;
          que.push(e.to);
        }
      }
    }
  }

 private:
  long long dfs(int v, int t, long long f) {
    if (v == t) return f;
    for (int& i = iter[v]; i < (int)G[v].size(); ++i) {
      FLOW::edge_flow& e = G[v][i];
      if (e.cap > 0 && dist[v] < dist[e.to]) {
        long long d = this->dfs(e.to, t, min(f, e.cap));
        if (d > 0) {
          e.cap -= d;
          G[e.to][e.rev].cap += d;
          return d;
        }
      }
    }
    return 0;
  }

 public:
  long long max_flow(int s, int t) {
    long long flow = 0;
    for (;;) {
      this->bfs(s);
      if (dist[t] < 0) return flow;
      iter = vector<int>(V, 0);
      long long f = this->dfs(s, t, INF);
      while (f > 0) {
        flow += f;
      }
    }
  }
};
}  // namespace FLOW
bool is_bipartite(int v, int c, vector<vector<int> >& G, vector<int>& Color) {
  Color[v] = c;
  for (int i = 0; i < (int)G[v].size(); ++i) {
    if (Color[G[v][i]] == c) return false;
    if (Color[G[v][i]] == 0 && !is_bipartite(G[v][i], -c, G, Color)) {
      return false;
    }
  }
  return true;
}
bool is_bipartite(int Root, vector<vector<int> >& Graph) {
  int GraphSize = Graph.size();
  vector<int> Color(GraphSize, 0);
  const int ColorNo = 1;
  return is_bipartite(Root, ColorNo, Graph, Color);
}
namespace matching {}
vector<vector<long long> > NCK;
void makeinv(vector<long long>& inv, const long long P) {
  int i;
  const int varMAX = max(100010, (int)inv.size());
  inv = vector<long long>(varMAX + 1, 0);
  inv[1] = 1;
  for (i = 2; i <= varMAX; i++) {
    inv[i] = (inv[P % i] * (P - P / i) % P) % P;
  }
}
long long nCk(long long N, long long k, long long mod = MOD) {
  static vector<long long> inv;
  if (inv.size() == 0) {
    makeinv(inv, mod);
  }
  k = min(k, N - k);
  if (k < 0 || k > N) {
    return 0;
  }
  if (k == 0) {
    return 1;
  }
  if (k == 1) {
    return N % mod;
  }
  long long ret = 1;
  for (int i = 1; i <= k; ++i) {
    ret = (ret * ((N + 1 - i) % mod)) % mod;
    ret = (ret * inv[i]) % mod;
  }
  return ret;
}
long long nCk_once(long long N, long long k, long long mod = MOD) {
  k = min(k, N - k);
  if (k < 0 || k > N) {
    return 0;
  }
  if (k == 0) {
    return 1;
  }
  if (k == 1) {
    return N % mod;
  }
  long long ret = 1;
  long long A = 1;
  for (long long i = 0; i < k; ++i) {
    A = (A * ((N - i) % mod)) % mod;
  }
  long long B = 1;
  for (long long i = 2; i <= k; ++i) {
    B = (B * (i % mod)) % mod;
  }
  ret = (A * powMod(B, mod - 2, mod)) % mod;
  return ret;
}
long long nCk_base(int N, int K, long long mod = MOD) {
  if (K < 0 || N < K) return 0;
  K = min(K, N - K);
  if (K == 0) {
    return 1 % mod;
  }
  if (K == 1) {
    return N % mod;
  }
  if (N <= 10000 && NCK[N][K]) {
    return NCK[N][K];
  }
  long long ans = (nCk_base(N - 1, K) + nCk_base(N - 1, K - 1)) % mod;
  if (N <= 10000) {
    NCK[N][K] = ans;
  }
  return ans;
}
class Point {
 public:
  double x, y;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  Point operator+(Point p) { return Point(add(x, p.x), add(y, p.y)); }
  void operator+=(Point p) {
    x = add(x, p.x);
    y = add(y, p.y);
  }
  Point operator-(Point p) { return Point(add(x, -p.x), add(y, -p.y)); }
  void operator-=(Point p) {
    x = add(x, -p.x);
    y = add(y, -p.y);
  }
  Point operator*(double a) { return Point(x * a, y * a); }
  double operator*(Point p) { return dot(p); }
  Point operator/(double a) { return Point(x / a, y / a); }
  double norm() { return sqrt(x * x + y * y); }
  double dot(Point p) { return add(x * p.x, y * p.y); }
  double rot(Point p) { return add(x * p.y, -y * p.x); }
  double add(double a, double b) {
    double EPS = 1e-10;
    if (abs(a + b) < EPS * (abs(a) + abs(b))) {
      return 0;
    }
    return a + b;
  }
};
istream& operator>>(istream& in, Point& P) {
  in >> P.x >> P.y;
  return in;
}
bool operator==(Point A, Point B) {
  if (A.x == B.x && A.y == B.y) return true;
  return false;
}
bool operator<(Point A, Point B) {
  if (A.x < B.x)
    return true;
  else if (A.x > B.x)
    return false;
  if (A.y < B.y) return true;
  return false;
}
bool operator>(Point A, Point B) {
  if (A < B) return false;
  if (A == B) return false;
  return true;
}
bool is_cross(Point p1, Point p2, Point q1, Point q2) {
  double res = (p2 - p1).rot(q2 - q1);
  return res != 0;
}
Point intersection(Point p1, Point p2, Point q1, Point q2) {
  return p1 + (p2 - p1) * ((q2 - q1).rot(q1 - p1) / (q2 - q1).rot(p2 - p1));
}
enum PointPotion {
  ONLINE_BACK = -2,
  CLOCKWISE,
  ON_SEGMENT,
  COUNTER_CLOCKWISE,
  ONLINE_FRONT
};
PointPotion ccw(Point A, Point B, Point C) {
  B -= A;
  C -= A;
  if (B.rot(C) > 0) return COUNTER_CLOCKWISE;
  if (B.rot(C) < 0) return CLOCKWISE;
  if (B.dot(C) < 0) return ONLINE_BACK;
  if (B.norm() < C.norm()) return ONLINE_FRONT;
  return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point q1, Point q2) {
  return (ccw(p1, p2, q1) * ccw(p1, p2, q2) <= 0) &&
         (ccw(q1, q2, p1) * ccw(q1, q2, p2) <= 0);
}
double dist_LineP(Point p1, Point p2, Point q1) {
  return abs((p2 - p1).rot(q1 - p1)) / (p2 - p1).norm();
}
double dist_SegP(Point p1, Point p2, Point q1) {
  if ((p2 - p1).dot(q1 - p1) < 0) {
    return (q1 - p1).norm();
  }
  if ((p1 - p2).dot(q1 - p2) < 0) {
    return (q1 - p2).norm();
  }
  return dist_LineP(p1, p2, q1);
}
double dist_segseg(Point A1, Point A2, Point B1, Point B2) {
  if (intersect(A1, A2, B1, B2)) {
    return 0;
  }
  return min(min(dist_SegP(A1, A2, B1), dist_SegP(A1, A2, B2)),
             min(dist_SegP(B1, B2, A1), dist_SegP(B1, B2, A2)));
}
int contains(vector<Point>& v, Point& P) {
  bool in = false;
  const int N = v.size();
  for (int i = 0; i < N; ++i) {
    Point A = (v[i] - P);
    Point B = (v[(i + 1) % N] - P);
    if (A.y > B.y) swap(A, B);
    if (A.y <= 0 && 0 < B.y) {
      if (A.rot(B) < 0) in = !in;
    }
    if (A.rot(B) == 0 && A.dot(B) <= 0) {
      return 1;
    }
  }
  return in ? 2 : 0;
}
bool cmp_x(const Point& p, const Point& q) {
  if (p.x != q.x) return p.x < q.x;
  return p.y < q.y;
}
vector<Point> convex_hull(vector<Point> ps, int n) {
  sort(ps.begin(), ps.end(), cmp_x);
  int k = 0;
  vector<Point> qs(n * 2);
  for (int i = 0; i < n; ++i) {
    while (k > 1 && (qs[k - 1] - qs[k - 2]).rot(ps[i] - qs[k - 1]) <= 0) {
      k--;
    }
    qs[k++] = ps[i];
  }
  for (int i = n - 2, t = k; i >= 0; i--) {
    while (k > t && (qs[k - 1] - qs[k - 2]).rot(ps[i] - qs[k - 1]) <= 0) {
      k--;
    }
    qs[k++] = ps[i];
  }
  qs.resize(k - 1);
  return qs;
}
double area(vector<Point> poly) {
  int size = poly.size();
  double ans = 0;
  for (int i = 1; i < size - 1; ++i) {
    ans += (poly[i] - poly[0]).rot(poly[i + 1] - poly[0]) / 2;
  }
  return ans;
}
bool compare_x(Point A, Point B) { return A.x < B.x; }
bool compare_y(Point A, Point B) { return A.y < B.y; }
double closest_pair(vector<Point>::iterator itr, int N) {
  if (N <= 1) return INF;
  int m = N / 2;
  double x = (itr + m)->x;
  double d = min(closest_pair(itr, m), closest_pair((itr + m), N - m));
  inplace_merge(itr, itr + m, itr + N, compare_y);
  vector<Point> B;
  for (int i = 0; i < N; ++i) {
    if (fabs((itr + i)->x - x) >= d) continue;
    int Bsize = B.size();
    for (int j = 0; j < Bsize; j++) {
      double dx, dy;
      dx = (itr + i)->x - B[Bsize - j - 1].x;
      dy = (itr + i)->y - B[Bsize - j - 1].y;
      if (dy >= d) break;
      d = min(d, hypot(dx, dy));
    }
    B.push_back(*(itr + i));
  }
  return d;
}
int CircleIntersection(Point A, double AR, Point B, double BR) {
  double D = (B - A).norm();
  if (D > AR + BR) {
    return 4;
  } else if (D == AR + BR) {
    return 3;
  } else if (abs(AR - BR) < D) {
    return 2;
  } else if (D == abs(AR - BR)) {
    return 1;
  } else if (D + AR < BR || D + BR < AR) {
    return 0;
  }
  return 0;
}
vector<Point> CircleLine(Point C, double CR, Point A, Point B) {
  vector<Point> ans(2);
  double a, b, c;
  a = -(A.y - B.y);
  b = A.x - B.x;
  c = -(a * A.x + b * A.y);
  double l, k, d;
  l = a * a + b * b;
  k = a * C.x + b * C.y + c;
  d = l * CR * CR - k * k;
  if (d > 0) {
    double ds = sqrt(d);
    double apl = a / l;
    double bpl = b / l;
    double xc = C.x - apl * k;
    double yc = C.y - bpl * k;
    double xd = bpl * ds;
    double yd = apl * ds;
    Point temp;
    ans[0].x = xc - xd;
    ans[0].y = yc + yd;
    ans[1].x = xc + xd;
    ans[1].y = yc - yd;
  } else if (d == 0) {
    Point temp;
    temp.x = C.x - a * k / l;
    temp.y = C.y - b * k / l;
    ans[0] = temp;
    ans[1] = temp;
  } else {
    Point temp;
    temp.x = INF;
    temp.y = INF;
    ans[0] = temp;
    ans[1] = temp;
  }
  return ans;
}
vector<Point> circle_cross(Point A, double RA, Point B, double RB) {
  Point C = B - A;
  double CC = C.dot(C);
  double ter = (CC + RA * RA - RB * RB) / 2;
  double D = CC * RA * RA - ter * ter;
  D = sqrt(D);
  vector<Point> ans(2);
  ans[0].x = (ter * C.x + C.y * D) / CC;
  ans[0].y = (ter * C.y - C.x * D) / CC;
  ans[1].x = (ter * C.x - C.y * D) / CC;
  ans[1].y = (ter * C.y + C.x * D) / CC;
  ans[0] += A;
  ans[1] += A;
  if (ans[0] == ans[1]) {
    ans.resize(1);
    return ans;
  }
  if (ans[0] > ans[1]) {
    swap(ans[0], ans[1]);
  }
  return ans;
}
class UnionFind {
 public:
  int cNum;
  vector<int> parent;
  vector<int> count;
  vector<vector<int> > GList;
  UnionFind(int n) {
    cNum = n;
    parent = vector<int>(n);
    count = vector<int>(n, 1);
    GList.resize(n);
    for (int i = 0; i < n; ++i) {
      parent[i] = i;
      GList[i].push_back(i);
    }
  }
  int find(int x) {
    if (parent[x] == x) {
      return x;
    }
    return parent[x] = find(parent[x]);
  }
  bool same(int x, int y) { return find(x) == find(y); }
  int Count(int x) { return count[find(x)]; }
  void add(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    parent[x] = y;
    count[y] += count[x];
  }
};
class BITree {
  int N;
  vector<long long> bit;

 public:
  BITree(int n) {
    N = n;
    bit = vector<long long>(N + 1, 0);
  }
  void add(int a, long long w) {
    if (a <= 0 || N < a) return;
    for (int i = a; i <= N; i += i & -i) {
      bit[i] += w;
    }
  }
  long long sum(int a) {
    long long ret = 0;
    if (a > N) a = N;
    for (int i = a; i > 0; i -= i & -i) {
      ret += bit[i];
    }
    return ret;
  }
};
template <class T, class U>
istream& operator>>(istream& in, pair<T, U>& P) {
  in >> P.first >> P.second;
  return in;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
  int size = v.size();
  for (int i = 0; i < size; ++i) {
    in >> v[i];
  }
  return in;
}
namespace mymat {
long long matMOD = MOD;
};
template <class T>
vector<vector<T> > operator*(vector<vector<T> >& A, vector<vector<T> >& B) {
  long long mod = mymat::matMOD;
  int R = A.size();
  int cen = A[0].size();
  int C = B[0].size();
  vector<vector<T> > ans(R, vector<T>(C, 0));
  for (int row = 0; row < R; ++row) {
    for (int col = 0; col < C; ++col) {
      for (int inner = 0; inner < cen; ++inner) {
        ans[row][col] = (ans[row][col] + A[row][inner] * B[inner][col]) % mod;
        ans[row][col] = (ans[row][col] + mod) % mod;
      }
    }
  }
  return ans;
}
template <class T>
vector<vector<T> > powMod(vector<vector<T> > mat, long long N,
                          long long mod = MOD) {
  mymat::matMOD = mod;
  int R = mat.size();
  int C = mat[0].size();
  vector<vector<T> > I(R, vector<T>(C, 0));
  for (int i = 0; i < R && i < C; ++i) {
    I[i][i] = 1;
  }
  if (N == 0) {
    return I;
  }
  vector<vector<T> > mul(R, vector<T>(C)), ans(R, vector<T>(C));
  ans = I;
  mul = mat;
  while (N) {
    if (N & 1) {
      ans = ans * mul;
    }
    N >>= 1;
    mul = mul * mul;
  }
  return ans;
}
namespace TIME {
time_t start, limit;
void time_start() { start = time(NULL); }
void time_set(int num) { limit = num; }
bool check() { return (time(NULL) - start < limit); }
}  // namespace TIME
namespace RAND {
mt19937 mt;
void rand_init() {
  random_device rnd;
  mt = mt19937(rnd());
}
int rand() { return mt(); }
}  // namespace RAND
template <typename T>
class segment_base {
  int N;
  vector<T> dat1;
  T VAL_E;

 public:
  segment_base(){};
  segment_base(int n, T val_E) : N(n), VAL_E(val_E) {
    dat1.resize(2 * n);
    dat1.assign(2 * n, val_E);
  }
  void init(int n, T val_E) {
    N = n;
    VAL_E = val_E;
    dat1.resize(2 * n);
    dat1.assign(2 * n, val_E);
  }
  T SELECT(T L, T R) {
    T ans;
    ans = min(L, R);
    return ans;
  }
  void update(int index, T val) {
    for (dat1[index += N] = val; index > 1; index >>= 1) {
      dat1[index >> 1] = SELECT(dat1[index], dat1[index ^ 1]);
    }
  }
  T query(int L, int R) {
    T ans = VAL_E;
    for (L += N, R += N; L < R; L >>= 1, R >>= 1) {
      if (L & 1) ans = SELECT(ans, dat1[L++]);
      if (R & 1) ans = SELECT(ans, dat1[--R]);
    }
    return ans;
  }
};
void solve() {
  int N, M;
  cin >> N >> M;
  vector<vector<edge_base> > gra(N), Rgra(N);
  UnionFind uf(N);
  for (int i = 0; i < M; ++i) {
    int L, R;
    long long D;
    cin >> L >> R >> D;
    --L;
    --R;
    uf.add(L, R);
    gra[L].push_back(make_edge_base(R, D));
    Rgra[R].push_back(make_edge_base(L, D));
  }
  vector<bool> useRoot(N, false);
  vector<bool> use(N, false);
  for (int i = 0; i < N; ++i) {
    int Root = uf.find(i);
    if (useRoot[Root]) {
      continue;
    }
    useRoot[Root] = true;
    vector<long long> dist(N, LINF);
    dist[i] = 0;
    queue<int> que;
    que.push(i);
    while (que.size()) {
      int v = que.front();
      que.pop();
      if (use[v]) {
        continue;
      }
      use[v] = true;
      int size = gra[v].size();
      for (int j = 0; j < size; ++j) {
        int u = gra[v][j].to;
        long long Len = gra[v][j].cost;
        if (dist[u] == LINF) {
          dist[u] = dist[v] + Len;
        } else {
          if (dist[u] != dist[v] + Len) {
            cout << "No" << endl;
            return;
          }
        }
        if (use[u] == false) {
          que.push(u);
        }
      }
      size = Rgra[v].size();
      for (int j = 0; j < size; ++j) {
        int u = Rgra[v][j].to;
        long long Len = Rgra[v][j].cost;
        if (dist[u] == LINF) {
          dist[u] = dist[v] - Len;
        } else {
          if (dist[u] != dist[v] - Len) {
            cout << "No" << endl;
            return;
          }
        }
        if (use[u] == false) {
          que.push(u);
        }
      }
    }
  }
  cout << "Yes" << endl;
}
signed main(void) {
  std::cin.tie(0);
  std::ios::sync_with_stdio(false);
  std::cout << std::fixed;
  cout << setprecision(16);
  solve();
}
