#include <bits/stdc++.h>

using namespace std;

#define forn(i, n) for (ll i = 0; i < (ll) (n); ++i)
#define sz(a) static_cast<int>((a).size())
#define pb emplace_back
#define mp make_pair
#define endl '\n'
#define f first
#define s second

#ifdef SEREZHKA
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define dbg(...)
#endif

template<typename T>
void _dbg(const char* _s, T _h) { cerr << _s << " = " << _h << "\n"; }

template<typename T, typename... Ts>
void _dbg(const char*_s, T _h, Ts... _t) {
    int _b = 0;
    
    while (((_b += *_s == '(') -= *_s == ')') != 0 || *_s != ',')
        cerr << *_s++;
    
    cerr << " = " << _h << ",";
    _dbg(_s + 1, _t...);
}

using ll = long long;

const ll INF = static_cast<ll>(1e9) + 7ll;
const ll LINF = INF * INF;
const int MAXN = static_cast<int>(1e6) + 17;

int n, m;
bool ok = true;
vector<int> g[MAXN];
ll col[MAXN], L[MAXN], R[MAXN];
ll kek[2];

bool read() {
    if (!(cin >> n))
        return false;

    forn (i, n - 1) {
        int u, v;
        cin >> u >> v;
        g[u - 1].pb(v - 1);
        g[v - 1].pb(u - 1);
    }

    cin >> m;
    fill(col, col + n, -1);

    forn (i, m) {
        int v, x;
        cin >> v >> x;
        col[v - 1] = x;
    }

    return true;
}

void dfs1(int v, int pr, int h) {
    if (col[v] != -1) {
        if (kek[h] == -1)
            kek[h] = col[v];

        if (1 & (col[v] ^ kek[h]))
            ok = false;

        L[v] = R[v] = col[v];
    }

    for (auto to : g[v])
        if (to != pr) {
            dfs1(to, v, (h ^ 1));
            L[v] = max(L[v], L[to] - 1);
            R[v] = min(R[v], R[to] + 1);
        }
}

void dfs2(int v, int pr, pair<ll, ll> up) {
    multiset<ll> Ls, Rs;
    Ls.insert(-INF * INF);
    Rs.insert(INF * INF);

    for (auto to : g[v])
        if (to != pr) {
            Ls.insert(L[to]);
            Rs.insert(R[to]);
        }

    if (pr != -1) {
        L[v] = max(L[v], up.f - 1);
        R[v] = min(R[v], up.s + 1);
        Ls.insert(up.f);
        Rs.insert(up.s);
    }

    for (auto to : g[v])
        if (to != pr) {
            auto curL = L[to];
            auto curR = R[to];
            Ls.erase(Ls.find(curL));
            Rs.erase(Rs.find(curR));
            dfs2(to, v, mp(*Ls.rbegin() - 1, *Rs.begin() + 1));
            Ls.insert(curL);
            Rs.insert(curR);
        }
}

void dfs(int v, int pr) {
    if (pr != -1)
        assert(abs(col[v] - col[pr]) == 1);
    for (auto to : g[v])
        if (to != pr) {
            if (col[to] == -1) {
                if (L[to] <= col[v] - 1 && col[v] - 1 <= R[to])
                    col[to] = col[v] - 1;
                else
                    col[to] = col[v] + 1;
            }

            dfs(to, v);
        }
}

void solve() {
    int root = -1;

    forn (i, n)
        if (col[i] != -1) {
            root = i;
            break;
        }

    kek[0] = kek[1] = -1;
    fill(L, L + n, -INF * INF);
    fill(R, R + n, INF * INF);
    dfs1(root, -1, 0);
    dfs2(root, -1, mp(-INF * INF, INF * INF));

    forn (v, n)
        if (L[v] > R[v])
            ok = false;

    if (!ok || (kek[0] != -1 && kek[1] != -1 && (kek[0] ^ kek[1]) % 2 == 0)) {
        cout << "No\n";
        return ;
    }

    dfs(root, -1);
    cout << "Yes\n";

    forn (i, n)
        cout << col[i] << endl;
}

int main() {
    cin.tie(nullptr);
    std::ios_base::sync_with_stdio(false);
    
    while (read())
        solve();
    
    return 0;
}



Measured memory_bytes: 76416