#include <bits/stdc++.h>
using namespace std;
void fill_solution(const vector<vector<pair<int, int> > >& G,
                   vector<int>& visited, vector<double>& weight, int start,
                   vector<pair<int, int> >& equation, double solution) {
  queue<int> q;
  q.push(start);
  visited[start] = 2;
  weight[start] = equation[start].first * solution + equation[start].second;
  while (!q.empty()) {
    int v = q.front();
    q.pop();
    for (auto u : G[v]) {
      if (visited[u.first] != 2) {
        q.push(u.first);
        visited[u.first] = 2;
        weight[u.first] =
            equation[u.first].first * solution + equation[u.first].second;
      }
    }
  }
}
long long find_solution(vector<pair<int, pair<int, int> > >& equations,
                        pair<int, int> sum_at_min) {
  sort(equations.begin(), equations.end());
  int best_x = equations[0].first;
  long long best_result =
      (long long)sum_at_min.first * best_x + sum_at_min.second;
  for (auto possiblity : equations) {
    int x = possiblity.first;
    int sign = possiblity.second.first;
    int a = possiblity.second.second;
    sum_at_min.first += 2;
    sum_at_min.second += 2 * sign * a;
    long long cur_result = (long long)sum_at_min.first * x + sum_at_min.second;
    if (cur_result < best_result) {
      best_result = cur_result;
      best_x = x;
    }
  }
  return best_x;
}
bool solve(const vector<vector<pair<int, int> > >& G, vector<int>& visited,
           vector<double>& weight, int start,
           vector<pair<int, int> >& equation) {
  bool is_solution_found = false;
  double solution = 0.0;
  pair<int, int> sum_at_min(0, 0);
  queue<int> q;
  vector<pair<int, pair<int, int> > > equations;
  q.push(start);
  visited[start] = 1;
  equation[start] = pair<int, int>(1, 0);
  sum_at_min.first -= 1;
  equations.push_back(pair<int, pair<int, int> >(0, pair<int, int>(1, 0)));
  while (!q.empty()) {
    int v = q.front();
    q.pop();
    for (auto neighbour : G[v]) {
      int u = neighbour.first;
      int c = neighbour.second;
      pair<int, int> u_equation(-equation[v].first, c - equation[v].second);
      if (!visited[u]) {
        equation[u] = u_equation;
        sum_at_min.first -= 1;
        sum_at_min.second -= u_equation.first * u_equation.second;
        visited[u] = 1;
        q.push(u);
        equations.push_back(pair<int, pair<int, int> >(
            -1 * u_equation.second * u_equation.first, u_equation));
      } else {
        if (u_equation != equation[u]) {
          if (u_equation.first == equation[u].first) {
            return false;
          }
          double current_solution =
              ((double)equation[u].second - u_equation.second) /
              (u_equation.first - equation[u].first);
          if (is_solution_found && fabs(current_solution - solution) > 0.001) {
            return false;
          }
          is_solution_found = true;
          solution = current_solution;
        }
      }
    }
  }
  if (!is_solution_found) {
    solution = find_solution(equations, sum_at_min);
  }
  fill_solution(G, visited, weight, start, equation, solution);
  return true;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int N, M;
  cin >> N >> M;
  vector<vector<pair<int, int> > > G(N);
  for (int i = 0; i < M; i++) {
    int a, b, c;
    cin >> a >> b >> c;
    G[a - 1].push_back(pair<int, int>(b - 1, c));
    G[b - 1].push_back(pair<int, int>(a - 1, c));
  }
  vector<int> visited(N, 0);
  vector<double> weight(N);
  vector<pair<int, int> > equation(N, pair<int, int>(0, 0));
  for (int i = 0; i < N; i++) {
    if (!visited[i]) {
      if (!solve(G, visited, weight, i, equation)) {
        cout << "NO\n";
        return 0;
      }
    }
  }
  cout << "YES\n";
  for (int i = 0; i < N - 1; i++) {
    cout << fixed << weight[i] << " ";
  }
  cout << fixed << weight[N - 1] << endl;
  return 0;
}
