#include <bits/stdc++.h>
#define whlie while
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define rep(i,N) for(int i = 0; i < (N); i++)
#define repr(i,N) for(auto i = (N) - 1; i >= 0; i -= 1)
#define each(x,v) for(auto& x : v)
#define all(v) (v).begin(),(v).end()
#define sz(v) ((int)(v).size())
#define vrep(v,it) for(auto it = v.begin(); it != v.end(); it++)
#define vrepr(v,it) for(auto it = v.rbegin(); it != v.rend(); it++)
#define ini(...) int __VA_ARGS__; in(__VA_ARGS__)
#define inl(...) ll __VA_ARGS__; in(__VA_ARGS__)
#define ins(...) string __VA_ARGS__; in(__VA_ARGS__)
#define rand mtrand
#ifdef NyaanDebug
  #include "NyaanDebug.h"
  #define trc(...) do { cout << #__VA_ARGS__ << " = "; dbg_out(__VA_ARGS__);} while(0)
  #define trca(v,N) do { cout << #v << " = "; array_out(v , N);cout << endl;} while(0)
#else
  #define trc(...)
  #define trca(...)
#endif
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector< vector<int> >;
constexpr int inf = 1001001001;
constexpr ll infLL = 0x1FFFFFFFFFFFFFFFLL;
struct IoSetupNya {IoSetupNya() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(15); cerr << fixed << setprecision(15);} } iosetupnya;
template<typename T, typename U> inline bool amin(T &x, U y) { return (y < x) ? (x = y, true) : false; }
template<typename T, typename U> inline bool amax(T &x, U y) { return (x < y) ? (x = y, true) : false; }
template<typename T, typename U> ostream& operator <<(ostream& os, const pair<T, U> &p) { os << p.first << " " << p.second; return os; }
template<typename T, typename U> istream& operator >>(istream& is, pair<T, U> &p) { is >> p.first >> p.second; return is; }
template<typename T> ostream& operator <<(ostream& os, const vector<T> &v) { int s = (int)v.size(); rep(i,s) os << (i ? " " : "") << v[i]; return os; }
template<typename T> istream& operator >>(istream& is, vector<T> &v) { for(auto &x : v) is >> x; return is; }
void in(){} template <typename T,class... U> void in(T &t,U &...u){ cin >> t; in(u...);}
void out(){cout << "\n";} template <typename T,class... U> void out(const T &t,const U &...u){ cout << t; if(sizeof...(u)) cout << " "; out(u...);}
template<typename T>void die(T x){out(x); exit(0);}

using P = pair<int,int>;
random_device seed_gen; mt19937_64 mtrand(seed_gen());
constexpr int MOD = 1000000007;
//////////////////////////////////////////

// セグ木
template<typename T,typename F,T UNIT>
struct ST{
  int size;
  vector<T> seg;
  F func;
  
  ST(int N,F func): func(func){
    size = 1;
    while(size < N) size <<= 1;
    seg.assign(2 * size, UNIT);
    build();
  }

  ST(const vector<T> &v,F func) : func(func){
    // initialize
    int N = (int)v.size();
    size = 1;
    while(size < N) size <<= 1;
    seg.resize(2 * size);
    // set
    for(int i=0;i < N; i++){
      seg[i + size] = v[i];
    }
    build();
  }

  void set(int k,T& x){
    seg[k + size] = x;
  }

  void build(){
    for(int k=size-1; k>0; k--){
      seg[k] = func(seg[2 * k] , seg[2 * k + 1]);
    }
  }
  
  void update(int k, T x){
    k += size; seg[k] = x;
    while(k >>= 1){
      seg[k] = func(seg[2 * k] , seg[2 * k + 1]);
    }
  }
  
  T query(int a, int b){
    T L = UNIT, R = UNIT;
    for(a+=size,b+=size; a<b; a>>=1,b>>=1){
      if(a & 1) L = func(L,seg[a++]);
      if(b & 1) R = func(seg[--b],R);
    }
    return func(L, R);
  }

  T operator[](const int &k) const{
    return seg[k + size];
  }

};

// HL分解
// 木の内部の任意の2点間をO(log_V)個に分割するデータ構造。
// これを用いることで木に対してセグ木やbitなどのデータ構造を用いることが出来る。
// 以下、内部のデータの説明。(頂点0を根とした。)
// size[i] ... iの部分木の要素数 depth[i] ... iの深さ(depth[0] = 0)
// nxt[i] ... vから根に向かって伸びるheavy pathの終着点(nxt[0] = 0)
// in[i],out[i] ... オイラーツアーした時の順番。
// [ in[i] , out[i] )で部分木へのクエリとなる。
// [ in[nxt[i]] , in[v] ]でheavy pathへのクエリとなる。
// par[i] ... iの親ノード。 (par[0] = 0)
// verify
// ABC133F https://atcoder.jp/contests/abc133/submissions/6357522
// AOJ-GRL-5C http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=3742268#1
// AOJ-GRL-5D https://onlinejudge.u-aizu.ac.jp/status/users/NyaanNyaan/submissions/1/GRL_5_D/judge/3742298/C++14
// AOJ-GRL-5E https://onlinejudge.u-aizu.ac.jp/status/users/NyaanNyaan/submissions/1/GRL_5_E/judge/3742347/C++14

vector<vector<int> > g;

struct HLD{
  int idx;
  vector<int> size, depth, in, out, nxt, par;
  HLD(int N,int root = 0):idx(0),size(N,0),depth(N,0),in(N,-1),
    out(N,-1),nxt(N,0),par(N,0){
    dfs_sz(root);
    trc(size); trc(depth);
    dfs_hld(root);
    trc(in); trc(out); trc(nxt);trc(par);
  }
  
  void build(int root){
    dfs_sz(root);
    dfs_hld(root);
  }

  // 構築
  void dfs_sz(int cur){
    size[cur] = 1;
    for(auto &dst: g[cur]){
      if(dst == par[cur]) {
        if( g[cur].size() >= 2 && int(dst) == int(g[cur][0]) ) 
          swap(g[cur][0] , g[cur][1]);
        else continue;
      }
      depth[dst] = depth[cur] + 1;
      par[dst] = cur;
      dfs_sz(dst);
      size[cur] += size[dst];
      if(size[dst] > size[g[cur][0]]){
        swap(dst , g[cur][0]);
      }
    }
  }
  void dfs_hld(int cur){
    in[cur] = idx++;
    for(auto dst: g[cur]){
      if(dst == par[cur]) continue;
      nxt[dst] = ( int(dst) == int(g[cur][0]) ? nxt[cur] : int(dst) );
      dfs_hld(dst);
    }
    out[cur] = idx;
  }

  // 辺クエリ
  // aからbへの辺(aが根の側,bが葉の側)の持つ値をstのdata[b]に代入しているとする。
  // (すなわち、辺のデータを葉の方の頂点に移し替える。)
  // (注: 例外処理のためdata[0] = fの単位元とする。)
  // この時、st.query(u,v + 1)はpar[u]からvまでの辺へのクエリとなる。
  // (注: st.query()は引数に半開区間をため第二引数のvに1を足している。)
  // これをもとに[u , v]の辺へのクエリを実装する。

  template<typename F>
  void edge_query(int u,int v,const F& f){
    while(1){
      if(in[u] > in[v]) swap(u,v);
      trc(u,v);
      if(nxt[u] != nxt[v]){
        f(in[nxt[v]] , in[v] + 1);
        v = par[ nxt[v] ];
      }
      else{
        trc(u , v,in[u] , in[v]);
        if(u != v) f(in[u] + 1, in[v] + 1);
        break;
      }
    }
  }

  // 頂点クエリ (verifyしていない)
  // 辺クエリと同様の議論をする。
  // たぶん最後の同じheavy pathに載ったところを、
  // in[u]+1からin[u]にかえれば正しく動くと思う。
  template<typename F>
  void node_query(int u,int v,const F& f){
    while(1){
      if(in[u] > in[v]) swap(u,v);
      trc(u,v);
      if(nxt[u] != nxt[v]){
        f(in[nxt[v]] , in[v] + 1);
        v = par[ nxt[v] ];
      }
      else{
        trc(u , v,in[u] , in[v]);
        f(in[u], in[v] + 1);
        break;
      }
    }
  }

  // 部分木クエリ
  template<typename F>
  void sub_edge_query(int u,const F& f){
    f(in[u] + 1, out[u]);
  }
  template<typename F>
  void sub_node_query(int u,const F& f){
    f(in[u], out[u]);
  }

  // 最小共通祖先 
  int lca(int a,int b){
    while(nxt[a] != nxt[b]){
      if( in[a] < in[b] ) swap(a,b);
      a = par[nxt[a]];
    }
    return depth[a] < depth[b] ? a : b;
  }
};

int main(){
  ini(N , Q);
  g.resize(N);
  rep(i , N - 1){
    ini(a,b); a--; b--;
    g[a].pb(b); g[b].pb(a);
  }
  HLD hld(N);
  auto f = [](ll a,ll b){return a + b;};
  ST<ll , decltype(f) , 0LL> st(N + 1, f);

  int p = 0 ; ll x = 0;
  auto fq = [&](int a, int b){
    st.update(a , x + st[a]);
    st.update(b , - x + st[b]);
  };
  rep(i,Q){
    in(p , x); p--;
    hld.sub_node_query<decltype(fq)>(p , fq);
  }

  rep(i,N){
    cout << (i?" ":"") << st.query(0 , hld.in[i] + 1);
  }
  out();

  
}

Measured memory_bytes: 30464