/* 
 *     Author:  srtry
 *     Created: 2026-01-10T16:34:04+09:00
 *     Coding:  utf-8-unix
 */

use proconio::input;
use std::io::{stdout,Write,BufWriter};
use std::collections::{VecDeque,BTreeSet,BTreeMap};

const BUFFSIZE:usize = 1000;
fn main() {
    input!{
        n:usize, a:usize, b:usize,
        x:[usize;n]
    }

    let out = stdout();
    let mut out = BufWriter::new(out.lock());
    
    let mut queue:BTreeMap<usize,usize> = x.iter().enumerate().map(|(i,&v)| (v,i)).collect();
    let mut group:BTreeSet<usize> = BTreeSet::new();  // indices
    let mut ans_vec:Vec<usize> = vec![0;n];
    let mut cnt = 0;

    loop {
        let mut subqueue:VecDeque<(usize,usize)> = VecDeque::new();   //index
        group.clear();
        if cnt == n {
            break;
        }    
        
        let (v,i) = queue.pop_first().unwrap();
        subqueue.push_back((v,i));
        
        loop {
            let from:(usize,usize);
            if let Some(y) = subqueue.pop_front() {
                from = y.clone();
            } else {
                let size = group.len();
                group.iter().for_each(|&i| ans_vec[i]=size);
                cnt += size;
                break;
            }

            // 後ろに探索
            let mut will_remove:BTreeSet<usize> = BTreeSet::new();
            for (&v,&i) in queue.range(from.0..) {
                let dist = v - from.0;
                if dist > b {
                    break;
                }
                if dist >= a {
                    subqueue.push_back((v,i));
                    will_remove.insert(v);
                }
            }

            // 前に探索
            for (&v,&i) in queue.range(0..from.0).rev() {
                let dist = from.0 - v;
                if dist > b {
                    break;
                }
                if dist >= a {
                    subqueue.push_back((v,i));
                    will_remove.insert(v);
                }
            }

            will_remove.iter().for_each(|&v| {queue.remove(&v);});
            will_remove.clear();
            group.insert(from.1);
        }
    }

    let ans_str_vec = {
        let mut vec:Vec<String> = vec![String::from("");n/BUFFSIZE + 1];
        for (i,&v) in ans_vec.iter().enumerate() {
            vec[i/BUFFSIZE] += &(v.to_string() + "\n");
        }
        vec
    };
    for e in ans_str_vec.iter() {
        out.write_all(e.as_bytes()).unwrap();
    };
}