use std::{cmp::{max, min}, collections::{BTreeMap, BTreeSet, VecDeque}};

fn read_line() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("No Line");
    buffer
}
fn read_lines<R, T: Fn(&str)->R> (count: usize, transformer: T) -> Vec<R> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(transformer(buffer.trim()));
    }
    vec
}
fn read_value<T: std::str::FromStr>() -> T {
    read_line().trim().parse().ok().unwrap()
}
fn read_values<T: std::str::FromStr>() -> Vec<T> {
    read_line().trim().split(' ').map(|x| x.parse().ok().expect("Can't Parse")).collect::<Vec<T>>()
}
fn read_tabulate<T: std::str::FromStr>(count: usize) -> Vec<T> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(buffer.parse().ok().expect("Can't Parse"));
    }
    vec
}
macro_rules! assign {
    () => {};
    ($($token:tt)*) => {
        let mut iter = read_values::<String>().into_iter();
        assign_iter!(iter, $($token)*);
    };
}
macro_rules! assign_iter {
    ($iter:expr) =>{};
    ($iter:expr,) =>{};
    ($iter:expr, $id:ident:$t:tt $($tail:tt)*) => {
        let $id: $t = $iter.next().unwrap().parse().ok().expect("Can't Parse");
        assign_iter!($iter, $($tail)*);
    };
    ($iter:expr, mut $id:ident:$t:tt $($tail:tt)*) => {
        let mut $id: $t = $iter.next().unwrap().parse().ok().expect("Can't Parse");
        assign_iter!($iter, $($tail)*)
    };
}
macro_rules! freeze {
    ($($id:ident), *) => {
        $(let $id = $id;)*
    };

}
#[derive(Copy, Clone)]
struct Range{
    from: i32, 
    to: i32,
}
fn no() -> () {
    println!("No");
}
fn main() {
    assign!{
        n: usize
    }
    let mut nodes = vec![Vec::new() as Vec<usize>; n];
    for _ in 1 .. n {
        assign! {
            a: usize
            b: usize
        }
        nodes[a - 1].push(b - 1);
        nodes[b - 1].push(a - 1);
    }
    assign!{k: usize}
    let mut value_range = vec![Range{from: -2000000, to: 2000000}; n];
    let mut parity = vec![-1; n];
    for _ in 0 .. k {
        assign!{
            v: usize
            p: i32
        }
        value_range[v - 1] = Range{from: p, to: p};
        parity[v - 1] = p & 1;
    }
    let mut ordering = Vec::new();
    let mut stack = Vec::new();
    let mut prev = vec![n; n];
    stack.push(0usize);
    while let Some(current) = stack.pop() {
        ordering.push(current);
        for &next in &nodes[current] {
            if prev[next] == n && next != 0 {
                prev[next] = current;
                stack.push(next);
            }
        }
    }
    freeze!(ordering, prev);
    for &current in &ordering {
        for &next in &nodes[current] {
            if prev[next] != current { continue;}
            if parity[current] != -1 {
                if parity[current] == parity[next] {
                    return no();
                }
                parity[next] = 1 - parity[current];
                value_range[next] = Range{from: max(value_range[next].from, value_range[current].from - 1), to: min(value_range[next].to, value_range[current].to + 1)};
                if (parity[next] ^ value_range[next].from) & 1 != 0 {
                    value_range[next].from += 1;
                }
                if (parity[next] ^ value_range[next].to) & 1 != 0 {
                    value_range[next].to -= 1;
                }
            }
        }
    }
    for &current in ordering.iter().rev() {
        if prev[current] == n {continue;}
        let next = prev[current];
        if parity[current] != -1 {
            if parity[current] == parity[next] {
                return no();
            }
            parity[next] = 1 - parity[current];
            value_range[next] = Range{from: max(value_range[next].from, value_range[current].from - 1), to: min(value_range[next].to, value_range[current].to + 1)};
            if (parity[next] ^ value_range[next].from) & 1 != 0 {
                value_range[next].from += 1;
            }
            if (parity[next] ^ value_range[next].to) & 1 != 0 {
                value_range[next].to -= 1;
            }
        }
    }
    for &current in &ordering {
        for &next in &nodes[current] {
            if prev[next] != current { continue;}
            if parity[current] != -1 {
                if parity[current] == parity[next] {return no();}
                parity[next] = 1 - parity[current];
                value_range[next] = Range{from: max(value_range[next].from, value_range[current].from - 1), to: min(value_range[next].to, value_range[current].to + 1)};
                if (parity[next] ^ value_range[next].from) & 1 != 0 {
                    value_range[next].from += 1;
                }
                if (parity[next] ^ value_range[next].to) & 1 != 0 {
                    value_range[next].to -= 1;
                }
            }
        }
    }
    let mut result = vec![0; n];
    for i in 0usize .. n {
        if value_range[i].from > value_range[i].to {return no();}
        result[i] = value_range[i].from;
    }
    freeze!(result);
    println!("Yes");
    for v in result {
        println!("{}", v);
    }
}


Measured memory_bytes: 12268