#include<cassert>
#include <bits/stdc++.h>
#ifndef IO_HPP
#define IO_HPP
#include<iostream>
#include<vector>
#include<queue>
#include<stack>
#include<array>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
using namespace std;
template<typename T1,typename T2>istream &operator>>(istream&,pair<T1,T2>&);
template<typename...Args>istream &operator>>(istream&,tuple<Args...>&a);
template<typename T>istream &operator>>(istream&is,vector<T>&a);
template<typename T,size_t N>istream &operator>>(istream&is,array<T,N>&a);
template<typename T1,typename T2>
istream &operator>>(istream&is,pair<T1,T2>&a){
  is>>a.first>>a.second;
  return is;
}
template<size_t pos,typename...Args>
void read_tuple(istream&is,tuple<Args...>&a){
  if constexpr(pos<tuple_size<tuple<Args...>>::value){
    is>>get<pos>(a);
    read_tuple<pos+1>(is,a);
  }
}
template<typename...Args>
istream &operator>>(istream&is,tuple<Args...>&a){
  read_tuple<0>(is,a);
  return is;
}
template<typename T>
istream &operator>>(istream&is,vector<T>&a){
  for(T&x:a)is>>x;
  return is;
}
template<typename T,size_t N>
istream &operator>>(istream&is,array<T,N>&a){
  for(T&x:a)is>>x;
  return is;
}
template<typename T1,typename T2>ostream &operator<<(ostream&os,const pair<T1,T2>&);
template<typename...Args>ostream &operator<<(ostream&os,const tuple<Args...>&);
template<typename T>ostream &operator<<(ostream&os,const vector<T>&);
template<typename T,typename Seq,typename Comp>ostream &operator<<(ostream&os,priority_queue<T,Seq,Comp>);
template<typename T>ostream &operator<<(ostream&os,queue<T>);
template<typename T>ostream &operator<<(ostream&os,deque<T>);
template<typename T>ostream &operator<<(ostream&os,stack<T>);
template<typename T,size_t N>ostream &operator<<(ostream&os,const array<T,N>&);
template<typename Key,typename Val,typename Comp>ostream &operator<<(ostream&os,const map<Key,Val,Comp>&);
template<typename Key,typename Val,typename Hash>ostream &operator<<(ostream&os,const unordered_map<Key,Val,Hash>&);
template<typename T,typename Comp>ostream &operator<<(ostream&os,const set<T,Comp>&);
template<typename T,typename Comp>ostream &operator<<(ostream&os,const multiset<T,Comp>&);
template<typename T,typename Hash>ostream &operator<<(ostream&os,const unordered_set<T,Hash>&);
template<typename T1,typename T2>
ostream &operator<<(ostream&os,const pair<T1,T2>&a){
  os<<a.first<<' '<<a.second;
  return os;
}
template<size_t pos,typename...Args>
void write_tuple(ostream&os,const tuple<Args...>&a){
  if constexpr(pos<tuple_size<tuple<Args...>>::value){
    if constexpr(pos>0)os<<' ';
    os<<get<pos>(a);
    write_tuple<pos+1>(os,a);
  }
}
template<typename...Args>
ostream &operator<<(ostream&os,const tuple<Args...>&a){
  write_tuple<0>(os,a);
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,const vector<T>&a){
  os<<'{';
  for(int i=0;i<(int)a.size();i++){
    os<<a[i];
    if(i+1!=a.size())os<<',';
  }
  os<<'}';
  return os;
}
template<typename T,typename Seq,typename Comp>
ostream &operator<<(ostream&os,priority_queue<T,Seq,Comp>a){
  os<<'{';
  if(!a.empty()){
    os<<a.top();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.top();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,queue<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.front();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.front();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,deque<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.front();a.pop_front();
    while(!a.empty()){
      os<<',';
      os<<a.front();
      a.pop_front();
    }
  }
  os<<'}';
  return os;
}
template<typename T>
ostream &operator<<(ostream&os,stack<T>a){
  os<<'{';
  if(!a.empty()){
    os<<a.top();a.pop();
    while(!a.empty()){
      os<<',';
      os<<a.top();
      a.pop();
    }
  }
  os<<'}';
  return os;
}
template<typename T,size_t N>
ostream &operator<<(ostream&os,const array<T,N>&a){
  os<<'{';
  for(int i=0;i<(int)a.size();i++){
    os<<a[i];
    if(i+1!=a.size())os<<',';
  }
  os<<'}';
  return os;
}
template<typename Key,typename Val,typename Comp>
ostream &operator<<(ostream&os,const map<Key,Val,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<"{["<<itr->first<<","<<itr->second<<']';
  while(++itr!=a.end())os<<",["<<itr->first<<','<<itr->second<<']';
  os<<'}';
  return os;
}
template<typename Key,typename Val,typename Hash>
ostream &operator<<(ostream&os,const unordered_map<Key,Val,Hash>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<"{["<<itr->first<<","<<itr->second<<']';
  while(++itr!=a.end())os<<",["<<itr->first<<','<<itr->second<<']';
  os<<'}';
  return os;
}
template<typename T,typename Comp>
ostream &operator<<(ostream&os,const set<T,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
template<typename T,typename Comp>
ostream &operator<<(ostream&os,const multiset<T,Comp>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
template<typename T,typename Hash>
ostream &operator<<(ostream&os,const unordered_set<T,Hash>&a){
  if(a.empty()){
    os<<"{}";
    return os;
  }
  auto itr=a.begin();
  os<<'{'<<*itr;
  while(++itr!=a.end())os<<','<<*itr;
  os<<'}';
  return os;
}
#endif
using namespace std;
using ll=long long;
using ull=unsigned long long;
using P=pair<ll,ll>;
template<typename T>using minque=priority_queue<T,vector<T>,greater<T>>;
template<typename T>bool chmax(T &a,const T &b){return (a<b?(a=b,true):false);}
template<typename T>bool chmin(T &a,const T &b){return (a>b?(a=b,true):false);}
template<typename T1,typename T2>void operator++(pair<T1,T2>&a,int){a.first++,a.second++;}
template<typename T1,typename T2>void operator--(pair<T1,T2>&a,int){a.first--,a.second--;}
template<typename T>void operator++(vector<T>&a,int){for(auto &i:a)i++;}
template<typename T>void operator--(vector<T>&a,int){for(auto &i:a)i--;}
#define overload3(_1,_2,_3,name,...) name
#define rep1(i,n) for(int i=0;i<(int)(n);i++)
#define rep2(i,l,r) for(int i=(int)(l);i<(int)(r);i++)
#define rep(...) overload3(__VA_ARGS__,rep2,rep1)(__VA_ARGS__)
#define reps(i,l,r) rep2(i,l,r)
#define all(x) x.begin(),x.end()
#define pcnt(x) __builtin_popcountll(x)
#define fin(x) return cout<<(x)<<'\n',static_cast<void>(0)
#define yn(x) cout<<((x)?"Yes\n":"No\n")
#define uniq(x) sort(all(x)),x.erase(unique(all(x)),x.end())
template<typename T>
inline int fkey(vector<T>&z,T key){return lower_bound(z.begin(),z.end(),key)-z.begin();}
ll myceil(ll a,ll b){return (a+b-1)/b;}
template<typename T,size_t n,size_t id=0>
auto vec(const int (&d)[n],const T &init=T()){
  if constexpr (id<n)return vector(d[id],vec<T,n,id+1>(d,init));
  else return init;
}
#ifdef LOCAL
#include<debug.h>
#define SWITCH(a,b) (a)
#else
#define debug(...) static_cast<void>(0)
#define debugg(...) static_cast<void>(0)
#define SWITCH(a,b) (b)
#endif
struct Timer{
  clock_t start;
  Timer(){
    start=clock();
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout<<fixed<<setprecision(16);
  }
  inline double now(){return (double)(clock()-start)/1000;}
  #ifdef LOCAL
  ~Timer(){
    cerr<<"time:";
    cerr<<now();
    cerr<<"ms\n";
  }
  #endif
}timer;
void SOLVE();
int main(){
  int testcase=1;
  //cin>>testcase;
  for(int i=0;i<testcase;i++){
    SOLVE();
  }
}
#include<type_traits>
#include<optional>
#include<variant>
struct BarrettReduction{
private:
  using i64=long long;
  using u64=unsigned long long;
  using u32=unsigned int;
  using u128=__uint128_t;
  u32 m;
  u64 im;
public:
  BarrettReduction():m(0),im(0){}
  BarrettReduction(u32 n):m(n),im(u64(-1)/n+1){}
  inline i64 quo(u64 x)const{
    if(m==1)return x;
    u64 y=u64((u128(x)*im)>>64);
    u32 r=x-y*m;
    return m<=r?y-1:y;
  }
  inline u32 rem(u64 x)const{
    if(m==1)return 0;
    u64 y=u64((u128(x)*im)>>64);
    u32 r=x-y*m;
    return m<=r?r+m:r;
  }
  inline std::pair<u64,u32>quo_rem(u64 x)const{
    if(m==0)return std::make_pair(x,0);
    u64 y=u64((u128(x)*im)>>64);
    u32 r=x-y*m;
    return m<=r?std::make_pair(y-1,r+m):std::make_pair(y,r);
  }
  inline u32 pow(u32 a,u64 p)const{
    u32 res=m!=1;
    while(p){
      if(p&1)res=rem(u64(res)*a);
      a=rem(u64(a)*a);
      p>>=1;
    }
    return res;
  }
};
constexpr std::pair<long long,long long>ext_gcd(long long a,long long b){
  if(b==0)return std::make_pair(1,0);
  auto [x,y]=ext_gcd(b,a%b);
  std::swap(x,y);
  return std::make_pair(x,y-a/b*x);
}
template<std::signed_integral T>
constexpr std::pair<T,T> inv_mod(T a,T b){
  a%=b;
  if(a<0)a+=b;
  if(a==0)return std::make_pair(b,0);
  T s=b,t=a;
  T m0=0,m1=1;
  while(t){
    T u=s/t;
    s-=t*u;
    m0-=m1*u;
    std::swap(s,t);
    std::swap(m0,m1);
  }
  if(m0<0)m0+=b/s;
  return std::make_pair(s,m0);
}
template<typename T,int id>
struct arbitrary_modint{
  using value_type=std::make_unsigned_t<T>;
  using mul_type=std::conditional_t<(std::numeric_limits<T>::digits<=32),uint64_t,__uint128_t>;
private:
  using mint=arbitrary_modint;
  value_type v;
  static value_type umod;
  static std::conditional_t<(std::numeric_limits<T>::digits<=32),BarrettReduction,std::monostate>br;
  mint sqrt_impl()const{
    if(this->val()<=1)return *this;
    if(umod%8==1){
      mint b=2;
      while(b.pow((umod-1)/2).val()==1)b++;
      value_type m2=umod-1;
      int e=0;
      while(m2%2==0)m2>>=1,e++;
      mint x=this->pow((m2-1)/2);
      mint y=(*this)*x*x;
      x*=*this;
      mint z=b.pow(m2);
      while(y.val()!=1){
        int j=0;
        mint t=y;
        while(t.val()!=1)t*=t,j++;
        z=z.pow((value_type(1))<<(e-j-1));
        x*=z;
        z*=z;
        y*=z;
        e=j;
      }
      return x;
    }
    else if(umod%8==5){
      mint res=this->pow((umod+3)/8);
      if((res*res).val()==this->val())return res;
      else return res*mint(2).pow((umod-1)/4);
    }
    else return this->pow((umod+1)/4);
  }
public:
  arbitrary_modint():v(0){}
  template<typename U,std::enable_if_t<std::signed_integral<U>||std::is_same_v<U,__int128_t>,std::nullptr_t> =nullptr>
  arbitrary_modint(U x){
    x%=std::make_signed_t<value_type>(umod);
    v=x>=0?x:x+umod;
  }
  template<typename U,std::enable_if_t<std::unsigned_integral<U>||std::is_same_v<U,__uint128_t>,std::nullptr_t> =nullptr>
  arbitrary_modint(U x):v(x%umod){}
  static void set_mod(T m){
    assert(1<=m);
    umod=m;
    if constexpr(std::numeric_limits<T>::digits<=32)br=BarrettReduction(umod);
  }
  static T mod(){return umod;}
  static mint raw(T x){
    mint res;
    res.v=x;
    return res;
  }
  inline T val()const{return v;}
  inline mint &operator+=(const mint&b){
    this->v+=b.v;
    if(this->v>=umod)this->v-=umod;
    return *this;
  }
  inline mint &operator-=(const mint&b){
    this->v-=b.v;
    if(this->v>=umod)this->v+=umod;
    return *this;
  }
  inline mint &operator*=(const mint&b){
    mul_type v=mul_type(this->v)*mul_type(b.v);
    if constexpr(std::numeric_limits<T>::digits<=32)this->v=br.rem(v);
    else this->v=v%umod;
    return *this;
  }
  inline mint &operator/=(const mint&b){return *this*=b.inv();}
  inline mint operator+()const{return *this;}
  inline mint operator-()const{return mint()-*this;}
  friend inline mint operator+(const mint&a,const mint&b){return mint(a)+=b;}
  friend inline mint operator-(const mint&a,const mint&b){return mint(a)-=b;}
  friend inline mint operator*(const mint&a,const mint&b){return mint(a)*=b;}
  friend inline mint operator/(const mint&a,const mint&b){return mint(a)/=b;}
  auto operator<=>(const mint&)const=default;
  inline mint operator++(int){
    mint res=*this;
    this->v++;
    if(this->v==umod)this->v=0;
    return res;
  }
  inline mint operator--(int){
    mint res=*this;
    if(this->v==0)this->v=umod;
    this->v--;
    return res;
  }
  template<std::integral U>
  mint pow(U k)const{
    if constexpr(std::is_signed_v<U>){
      assert(0<=k);
    }
    mint res=1,a(*this);
    while(k){
      if(k&1)res*=a;
      a*=a;
      k>>=1;
    }
    return res;
  }
  mint inv()const{
    mint res;
    auto [g,x]=inv_mod<std::make_signed_t<value_type>>(this->v,umod);
    assert(g==1);
    res.v=x;
    return res;
  }
  std::optional<mint>sqrt()const{
    if(this->val()<=1||this->pow((umod-1)/2)==1)return std::make_optional(this->sqrt_impl());
    else return std::nullopt;
  }
  friend std::istream &operator>>(std::istream&is,mint&b){
    long long a;
    is>>a;
    b=mint(a);
    return is;
  }
  friend std::ostream &operator<<(std::ostream&os,const mint&b){
    os<<b.val();
    return os;
  }
};
template<typename T,int id>typename arbitrary_modint<T,id>::value_type arbitrary_modint<T,id>::umod=2;
template<typename T,int id>std::conditional_t<(std::numeric_limits<T>::digits<=32),BarrettReduction,std::monostate>arbitrary_modint<T,id>::br;
template<typename T,int id>
struct std::hash<arbitrary_modint<T,id>>{
  std::size_t operator()(arbitrary_modint<T,id>x)const{
    return std::hash<unsigned int>()(x.val());
  }
};
using mint=arbitrary_modint<int,1>;
void SOLVE(){
  int n,m;
  cin>>n>>m;
  mint::set_mod([](){int b;cin>>b;return b;}());
  vector<vector<pair<int,mint>>>g(n);
  rep(i,m){
    int u,v;
    mint w;
    cin>>u>>v>>w;
    u--,v--;
    g[u].emplace_back(v,w);
    g[v].emplace_back(u,w);
  }
  vector<mint>ans(n);
  vector<bool>vis(n);
  rep(i,n)if(!vis[i]){
    rep(j,mint::mod()){
      auto pre=vis;
      ans[i]=j;
      queue<int>que;
      que.push(i);
      vis[i]=true;
      bool ok=true;
      while(!que.empty()){
        int x=que.front();que.pop();
        for(auto [y,w]:g[x]){
          if(!vis[y]){
            vis[y]=true;
            ans[y]=w-ans[x];
            que.push(y);
          }
          else if(ans[x]+ans[y]!=w){
            ok=false;
            break;
          }
        }
      }
      if(ok)break;
      if(j+1==mint::mod())fin("No");
      vis=pre;
    }
  }
  cout<<"Yes\n";
  rep(i,n)cout<<ans[i]<<" \n"[i+1==n];
}