#include <iostream>
#include <fstream>
#include <vector>
using namespace std;
using VI = vector<int>;
using VB = vector<bool>;
using VVI = vector<VI>;

ifstream fin("arbore.in");
ofstream fout("arbore.out");

const int MAX_N = 1e5 + 5, INF = 0x3f3f3f3f;
int n, m;
int pos[MAX_N], tin[MAX_N], tout[MAX_N], timer;
VI seg, lazy;
VVI adj;

void ReadInput();
void Solve();
void DFS(int node, int fa);
void Update(int node, int start, int fin, int l, int r, int val);
void PushDown(int node, int start, int fin);

int main()
{
    ReadInput();
    DFS(1, 0);
    Solve();

    return 0;
}

void Solve()
{
    seg = VI(4 * timer + 5, 0);
    lazy = VI(4 * timer + 5, -INF);

    fout << timer << '\n';

    int type, node, sum;
    while (m--)
    {
        fin >> type;

        if (type == 1)
        {
            fin >> node >> sum;

            Update(1, 1, timer, tin[node], tout[node], sum);
        }
        else
        {
            fin >> sum;
        }
    }

    for (int t = 1; t <= 4 * timer; ++t)
        fout << seg[t] << ' ';
}

void Update(int node, int start, int fin, int l, int r, int val)
{
    PushDown(node, start, fin);

    if (r < start || l > fin)
        return;

    if (l <= start && r >= fin)
    {
        lazy[node] = val;
        PushDown(node, start, fin);
        return;
    }

    int mid = (start + fin) / 2;
    Update(2 * node, start, mid, l, r, val);
    Update(2 * node + 1, mid + 1, fin, l, r, val);

    seg[node] = seg[2 * node] + seg[2 * node + 1];
}

void PushDown(int node, int start, int fin)
{
    if (lazy[node] != -INF)
    {
        seg[node] = (fin - start + 1) * lazy[node];

        if (start != fin)
        {
            lazy[2 * node] = lazy[2 * node + 1] = lazy[node];
        }

        lazy[node] = -INF;
    }
}

void DFS(int node, int fa)
{
    tin[node] = ++timer;
    pos[timer] = node;

    for (int nbr : adj[node])
        if (nbr != fa)
            DFS(nbr, node);

    tout[node] = timer;
}

void ReadInput()
{
    fin >> n >> m;

    adj = VVI(n + 1);

    int u, v;
    for (int i = 1; i < n; ++i)
    {
        fin >> u >> v;

        adj[u].push_back(v);
        adj[v].push_back(u);
    }
}