#include <iostream>
#include <stdlib.h>
#include <vector> //vector
#include <algorithm> //sort()
#include <numeric>
#include <tuple>
#include <cmath>
#include <queue>

#define rep(i, n) for(int i=0; i<(int)(n);i++)
#define rep1(i, n) for(int i=1; i<=(int)(n);i++)
#define all(x) (x).begin(), (x).end()
#define debug(a) if(flagdebug){cout << "debug (" #a "):" << endl << (a) << endl;}

typedef uint64_t ulint;
typedef int64_t lint;

using namespace std;

template<class T> inline bool chmin(T& a, T b);
template<class T> inline bool chmax(T& a, T b);
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v);

template<class T> lint sum(vector<T> a);
template<class T> double ave(vector<T> a);

struct node
{
    // lint x;
    // lint y;
    // lint dist;

    //node* child;
    //node* next;
    lint childno;
    lint nextno;
    lint value;
    lint no;
    lint parentno;
    lint lastnextno;





public:
    node()
    {
        no = 0;
        //child = NULL;
        //next = NULL;
        childno = 0;
        nextno = 0;
        value = 0;
        parentno = 0;
        lastnextno = 0;
    }

    // bool operator<(const pos &another) const
    // {
    //     return x < another.x;//年齢を比較
    // };
    
};

//lint a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z;


bool flagdebug = false;


int main(){
//////////////////////////////////////////////////////

    //flagdebug = true; ///本番時削除！！！！！

    //入力

    lint n , q;
    cin >> n >> q;

    vector<node> tree(n + 1);
    //vector<lint> a(n);
    // rep1(i,n)
    // {
    //     tree[i].no = i;
    // }
    rep(i, n-1)
    {
        //tree[i + 1].no = i + 1;
        lint a , b;
        cin >> a >> b;

        if(tree[a].childno == 0)
        {
            tree[a].childno = b;
            tree[b].parentno = a;
            tree[b].lastnextno = b;
        }
        else
        {
            
            
            lint first = tree[a].childno;
            // while(tree[p].nextno != 0)
            // {
            //     p = tree[p].nextno;
            // }

            lint last = tree[b].lastnextno;
            tree[last].nextno = b;
            tree[first].lastnextno = b;
            tree[b].parentno = tree[first].parentno;
            
            // if(last != 0)
            // {
                
                
                

            // }

            
        }
        

        // if(tree[a].child == NULL)
        // {
        //     tree[a].child = &tree[b];
        // }
        // else
        // {
        //     node *p = tree[a].child;
        //     while(p->next != NULL)
        //     {
        //         p = p->next;
        //     }
        //     p->next = &tree[b];
        // }
        
    }
    //tree[n].no = n;

    rep(i, q)
    {
        lint p , x;
        cin >> p >> x;
        tree[p].value += x;
        
    }

    // rep1(i, n)
    // {
    //     //cout << i <<": " <<tree[i].value << " child:" << tree[i].child->no ;//<< " next:" << tree[i].next->no << endl;
    //     cout << i <<": " <<tree[i].value << " child:" << tree[i].childno << " next:" << tree[i].nextno<< "parent:" << tree[i].parentno << endl;
    // }


    rep1(i,n)
    {

        if(tree[i].parentno != 0)
        {
            tree[i].value += tree[tree[i].parentno].value;
        }

        if(i != n)
        {
            cout << tree[i].value << " ";
        }
        else
        {
            cout << tree[i].value << endl;
        }



        // if(tree[i].childno != 0)
        // {
        //     tree[tree[i].childno].value += tree[i].value;
        // }
        // lint nextchild = tree[tree[i].childno].nextno;
        // while(nextchild != 0)
        // {
        //     tree[nextchild].value += tree[i].value;
        //     nextchild = tree[nextchild].nextno;
        // }
    }

    // cout << endl;


    //2次元配列
    //vector<vector<lint>> mat(row, vector<lint>(column, 初期値));
    //ペア
    //pair<lint,lint> p = make_pair(1,2);
    //vector<pair<lint,lint>> c(100010, pair<lint,lint>(0,0));
    //タプル
    //tuple<lint,lint,lint> t  = make_tuple(1,2,3);


    //昇順ソート
    //sort(all(a));
    //降順ソート
    //sort(all(a),greater<lint>());
    //特殊なソート（ラムダ式）
    //sort(all(mat), [&i](const vector<lint> &a, const vector<lint> &b){return a[i] < b[i];});
    // //[&i]は参照する変数，いらなければからの大括弧でよし．
    
    //////////////////////////////////////////////////////
    //キュー
    //queue<lint> que;
    //que.push(value);
    //que.front(); //先頭を参照
    //que.top(); //トップを参照（消されないので消したい場合は直後にpop()を使う）
    //que.pop(); //追い出す
    //que.empty(); //空なら1，あれば0
    //優先度付きキュー
    //priority_queue<lint> que;
    //キューにque.push()で入れると最大値順に並べられる．que.pop()で取り出すときは常に最大値が前にくる．
    //最小値から取り出したい時はpriority_queue< lint, std::vector<lint>, std::greater<lint> >
    //////////////////////////////////////////////////////
    //スタック
    //stack<lint> stk;
    //stk.push(value);
    //stk.top(); //先頭を参照（消されないので消したい場合は直後にpop()を使う）
    //stk.pop(); //トップを削除
    //stk.empty(); //空なら1,あれば0
    //stk.size(); //数
    //


   

    // sort(input.begin() , input.end());

    // uint64_t max = numeric_limits<uint64_t>::max();


    //////////////////////////////////////////////////////
    // DP

//     // 無限大の値
//     const uint64_t INF = (uint64_t)1 << 60;
//     //const int64_t NINF = -1 * ((int64_t)1 << 60 );
 
//     // DP テーブル
//     uint64_t dp[100010];

//     //DPテーブル初期化（最小化用）
//     for (int i = 0; i < 100010; ++i)
//     {
//         //dp[i] = INF;
//         dp[i] = 0;
//     } 

//     // 初期条件
//     dp[0] = 0;

//     // ループ
//     for (int i = 1; i <= n; ++i) {
//         //chmin( dp[i], dp[i - 1] + abs( input[i] - input[i - 1] ));
//         //if (i < 2)continue;
//         //chmin( dp[i], dp[i - 2] + abs( input[i] - input[i - 2] ));



//         // chmax ( dp [i] , dp[i - 1]);
//         // chmax ( dp [i] , dp[i - 1] + input[i]);
//         // cout << "dp[" << i <<"] = " << dp[i] << endl;

//     }



// //////////////////////////////////////////////////////

//     cout << dp[n] << endl;

//////////////////////////////////////////////////////
// Ctrl + Opt + N to make
    return 0;
}


//最小化用関数
template<class T> inline bool chmin(T& a, T b)
{
    if (a > b) 
    {
        a = b;
        return true;
    }
    return false;
}

//最大化関数
template<class T> inline bool chmax(T& a, T b)
{
    if (a < b)
    {
        a = b;
        return true;
    }
    return false;
}


// vectorprint用
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
	int len = v.size();
	for (int i = 0; i < len; ++i) {
		s << v[i]; if (i < len - 1) s << "\t";
	}
	return s;
}

// //合計
// template<class T> lint sum(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0);
// }


// //平均
// template<class T> double ave(vector<T> a)
// {
//     return std::accumulate(a.begin(), a.end(), 0.0) / a.size();
// }


// 最大公約数
ulint gcd(lint a, lint b)
{
    if(b!=0)
    {
        gcd(b, a % b);
    }
    return a;    
}

ulint gcd(vector<lint> v)
{
    lint l = v.size();
    if(l>=2)
    {
        v[l-2] = gcd(v[l-2] , v[l-1]);
        v.pop_back();
    }
    if(l==1)return v[0];
    else
    {
        return 0;
    } 
}

//最小公倍数
ulint lcm(lint a, lint b)
{
    return a / gcd(a, b) * b;
}

ulint lcm(vector<lint> v)
{
    lint l = v.size();
    if(l>=2)
    {
        v[l-2] = lcm(v[l-2], v[l-1]);
        v.pop_back();
    }
    if(l==1)return v[0];
    else
    {
        return 0;
    }
}

Measured memory_bytes: 11776