use std::collections::{HashMap, HashSet};

fn main() {
    proconio::input! {
        n: usize,
        a: i64,
        b: i64,
        x: [i64; n],
    }
    let mut stations: HashMap<usize, HashSet<usize>> =
        (0..n).into_iter().map(|i| (i, HashSet::new())).collect();
    for i in 0..n {
        for j in (0..i).rev().skip(1) {
            let abs = (x[j] - x[i]).abs();
            if between(a, b, abs) {
                stations.get_mut(&i).unwrap().insert(j);
            } else if abs > b {
                break;
            }
        }
        for j in (i..n).skip(1) {
            let abs = (x[j] - x[i]).abs();
            if between(a, b, abs) {
                stations.get_mut(&i).unwrap().insert(j);
            } else if abs > b {
                break;
            }
        }
    }

    let mut groups = vec![];
    loop {
        let mut visited = HashSet::new();
        if let Some(s) = stations.iter().find(|x| !x.1.is_empty()) {
            visited.insert(*s.0);
        } else {
            break;
        }
        loop {
            let mut inserted = false;
            for s in visited.clone() {
                for v in stations.get(&s).unwrap().iter() {
                    inserted |= visited.insert(*v);
                }
            }
            if !inserted {
                break;
            }
        }
        for v in visited.iter() {
            stations.remove(v);
        }
        groups.push(visited);
    }
    for s in stations {
        groups.push(HashSet::from_iter([s.0]));
    }
    let stations = (0..n)
        .into_iter()
        .map(|i| groups.iter().find(|x| x.contains(&i)).unwrap().len())
        .collect::<Vec<usize>>();
    for s in stations {
        println!("{}", s);
    }
}

fn between(a: i64, b: i64, x: i64) -> bool {
    a <= x && x <= b
}