const epsilon: f64 = 1e-9;
fn main() {
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    let mut input_iter = input.split_whitespace();
    let de: i64 = input_iter.next().unwrap().parse().unwrap();

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    let mut input_iter = input.split_whitespace();
    let ab: i64 = input_iter.next().unwrap().parse().unwrap();

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).unwrap();
    let mut input_iter = input.split_whitespace();
    let ac: i64 = input_iter.next().unwrap().parse().unwrap();

    let mut res = false;
    for bd in 1..=100 {
        for ec in 1..=100 {
            if !can_triangle((bd + de + ec) as f64, ab as f64, ac as f64) {
                continue;
            }
            
            if let Some(dba) = angle(ac as f64, ab as f64, (bd + de + ec) as f64) {
            if let Some(eca) = angle(ab as f64, ac as f64, (bd + de + ec) as f64) {
            if let Some(ad) = length(ab as f64, bd as f64, dba) {
            if let Some(ae) = length(ac as f64, ec as f64, eca) {
                if !can_triangle(bd as f64, ab as f64, ad as f64) {
                    continue;
                }
                if !can_triangle(ec as f64, ac as f64, ae as f64) {
                    continue;
                }
                if let Some(bad) = angle(bd as f64, ab as f64, ad as f64) {
                if let Some(cae) = angle(ec as f64, ac as f64, ae as f64) {
                    if (bad - cae).abs() < epsilon {
                        res = true;
                    }
                }
                }
            }
            }
            }
            }
        }
    }
    println!("{}", if res {"Yes"} else {"No"});
}

fn angle(a: f64, b: f64, c: f64) -> Option<f64> {
    let cos = (b * b + c * c - a * a) / (2.0f64 * b * c);
    if cos.abs() > 1.0f64 {
        return None;
    }
    return Some(cos.acos());
}

fn length(b: f64, c: f64, cab: f64) -> Option<f64> {
    let axa = b * b + c * c - 2.0 * b * c * cab.cos();
    if axa < 0.0f64 {
        return None;
    }
    return Some(axa.sqrt());
}

fn can_triangle(a: f64, b: f64, c: f64) -> bool {
    return can_triangle0(a, b, c) || can_triangle0(c, a, b) || can_triangle0(b, c, a);
}

fn can_triangle0(a: f64, b: f64, c: f64) -> bool {
    return a >= b.max(c) && a < b + c;
}