// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



using i32 = std::int_fast32_t;

using i64 = std::int_fast64_t;

template <typename T> constexpr T inf = numeric_limits<T>::has_infinity ? numeric_limits<T>::infinity() : numeric_limits<T>::max() / 4;



#define REP(i, stop) FOR(i, 0, stop)

#define FOR(i, start, stop) for (int i = start, i##_len = stop; i < i##_len; ++i)

#define RREP(i, n) for (int i = n; i-- > 0;)

#define ALL(v) (v).begin(), (v).end()

#define RALL(v) (v).rbegin(), (v).rend()

#define COMP(key) [](const auto& a, const auto& b) { return a.key < b.key; }



template<typename T, typename U> istream& operator>>(istream& is, pair<T, U>& a) { return is >> a.first >> a.second; }

template<typename T> istream& operator>>(istream& is, vector<T>& a) { for (T& x : a) is >> x; return is; }



void LOG(const int& x) { cerr << x << "\n"; }

template<typename T> void LOG(const vector<T>& a) { for (const T& x : a) cerr << x << " "; cerr << "\n"; }

template<typename T, std::size_t S> void LOG(const T (&a)[S]) { REP(i, S) cerr << a[i] << " "; cerr << "\n"; }

template<typename T, std::size_t S, std::size_t R> void LOG(const T (&a)[S][R]) { REP(i, S) { REP(j, R) cerr << a[i][j] << " "; cerr << "\n"; } }



i64 ceil(i64 a, i64 b) { return (a - 1) / b + 1; }

i64 gcd(i64 a, i64 b) { while (b != 0) { i64 t = b; b = a % b; a = t; } return a; }

i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }

i64 gcd(const vector<i64>& v) { return accumulate(ALL(v), 1LL, static_cast<i64(*)(i64, i64)>(gcd)); }

i64 lcm(const vector<i64>& v) { return v.empty() ? 0LL : accumulate(v.begin() + 1, v.end(), v[0], static_cast<i64(*)(i64, i64)>(lcm)); }

i64 pow(i64 x, i64 y, i64 z) { i64 a = 1; while (y > 0) { if (y & 1) a = a * x % z; x = x * x % z; y /= 2; } return a; }

i64 inv(i64 x, i64 m) { return pow(x, m - 2, m); }



struct InitCpp { InitCpp() { cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(10); } } initCpp;



using P = pair<i64, i64>;

signed main() {

  i64 N, Q;

  cin >> N >> Q;

  vector<vector<i64>> G(N);

  REP(_, N - 1) {

    i64 a, b;

    cin >> a >> b;

    a -= 1;

    b -= 1;

    G[a].push_back(b);

    G[b].push_back(a);

  }

  vector<i64> cnt(N);

  REP(_, Q) {

    i64 p, x;

    cin >> p >> x;

    p -= 1;

    cnt[p] += x;

  }

  vector<i64> ans(N);

  vector<bool> used(N, false);

  stack<P> st;

  st.push({0, 0});

  while (st.size()) {

    P a = st.top();

    st.pop();

    i64 v = cnt[a.first] + a.second;

    ans[a.first] = v;

    used[a.first] = true;

    for (i64 b : G[a.first]) {

      if (!used[b]) {

        st.push({b, v});

      }

    }

  }

  REP(i, N) {

    cout << ans[i] << " ";

  }

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <stack>

#include <vector>

using namespace std;



using i64 = long long;



#define REP(i, stop) for (register int i = 1; i <= stop; ++i)



const int is = 1 << 17;

char ib[is], *ip = ib + is, it;

inline char getc() {

	if (ip == ib + is) { fread_unlocked(ib, 1, is, stdin); ip = ib; }

	return *ip++;

}

inline int read() {

	int r = 0;

	if (ip + 16 > ib + is) while ((it = getc()) & 16) r = r * 10 + it - '0';

	else while ((it = *ip++) & 16) r = r * 10 + it - '0';

	return r;

}



const int os = 1 << 17;

char ob[os], *op = ob, ot;

inline void putc(const char c) {

	*op++ = c;

	if (op == ob + os) { fwrite_unlocked(ob, 1, os, stdout); op = ob; }

}

// x shoud be greater than or equal to zero

inline void write(i64 x) {

	char d[20];

	int i = 0;

	while (true) {

		d[i] = x % 10 + 48;

		x /= 10;

		++i;

		if (x <= 0) break;

	}

	while (i--) {

		putc(d[i]);

	}

	putc(' ');

}



i64 cnt[200001];

bool used[200001];

i64 st[200001], *tp;

signed main() {

  i64 N = read(), Q = read();

  vector<vector<i64>> G(N + 1);

  REP(_, N - 1) {

    i64 a = read(), b = read();

    G[a].push_back(b);

    if (a != 1) G[b].push_back(a);

  }

  REP(_, Q) {

    i64 p = read(), x = read();

    cnt[p] += x;

  }

  tp = st;

  ++tp;

  *tp = 1;

  while (*tp) {

    i64 a = *tp;

    --tp;

    used[a] = true;

    for (i64 b : G[a]) {

      if (!used[b]) {

        cnt[b] += cnt[a];

        ++tp;

        *tp = b;

      }

    }

  }

  REP(i, N) {

    write(cnt[i]);

  }

  fwrite_unlocked(ob, 1, op - ob, stdout);

}


// Fastest known solution for this problem: