use std::io::*;
use std::str::FromStr;
use std::collections::HashMap;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[allow(dead_code)]
fn print_s(s: &Vec<char>) {
    for &c in s.iter() {
        print!("{}", c);
    }
    println!("");
}

fn expand_s(s: &Vec<char>) -> Vec<char> {
    let BASE = 1e+9 as usize + 7;
    let mut POW_BASE = 1;
    let MOD = 1e9 as usize + 9;
    let mut skip = 0;
    let mut left = 0;
    let mut right = 0;
    for i in 0..s.len() / 2 - 1 {
        left = (left * BASE + (s[i] as u8 - 'a' as u8) as usize) % MOD;
        right = (right + POW_BASE * (s[s.len() - i - 1] as u8 - 'a' as u8) as usize) % MOD;
        POW_BASE = (POW_BASE * BASE) % MOD;
        if left == right {
            skip = i + 1;
        }
    }
    // println!("{}", skip);
    let ret = s.iter()
        .chain(s[skip..s.len() - skip].iter())
        .cloned()
        .collect::<Vec<_>>();

    // check
    assert!(ret.len() % 2 == 0);
    for i in 0..ret.len() / 2 {
        assert!(ret[i] == ret[i + ret.len() / 2]);
    }
    ret
}

#[allow(dead_code)]
fn naive(s: &Vec<char>, l: usize, r: usize) -> Vec<usize> {
    let mut s = s.clone();
    while s.len() < r {
        s = expand_s(&s);
    }
    let mut cnts = vec![0; 26];
    for i in l..r {
        cnts[(s[i] as u8 - 'a' as u8) as usize] += 1;
    }
    cnts
}

fn solve(s: &Vec<char>, l: usize, r: usize) -> Vec<usize> {
    let mut temp_s = s.clone();
    let mut lens = vec![s.len()];
    for _ in 0..2 {
        temp_s = expand_s(&temp_s);
        lens.push(temp_s.len());
    }
    // println!("{:?}", lens);
    for i in 2.. {
        if r <= lens[i] {
            break;
        }
        if lens[0] + lens[1] == lens[2] {
            let v = lens[i - 1] + lens[i];
            lens.push(v);
        } else {
            assert!(lens[2] - lens[1] == lens[1] - lens[0]);
            let v = lens[i] * 2;
            lens.push(v);
        }
    }
    // println!("{:?}", lens);
    let mut ranges = HashMap::<(usize, usize), usize>::new();
    ranges.insert((l, r), 1);
    for i in (1..lens.len()).rev() {
        // println!("{} {}", i, ranges.len());
        let mut nranges = HashMap::<(usize, usize), usize>::new();
        let skip = lens[i - 1] - lens[i] / 2;
        let prev = lens[i - 1];
        for (&range, &cnt) in ranges.iter() {
            if range.1 <= prev {
                *nranges.entry(range).or_insert(0) += cnt;
            } else if prev <= range.0 {
                let offset = range.0 - prev;
                *nranges
                    .entry((skip + offset, range.1 - prev + skip))
                    .or_insert(0) += cnt;
            } else {
                *nranges.entry((range.0, prev)).or_insert(0) += cnt;
                *nranges.entry((skip, range.1 - prev + skip)).or_insert(0) += cnt;
                assert!(range.1 - prev + skip <= prev);
                assert!(prev - range.0 + range.1 - prev + skip - skip == range.1 - range.0);
            }
        }
        ranges = nranges;
    }
    let mut cnts = vec![0; 26];
    for (&range, &cnt) in ranges.iter() {
        for i in range.0..range.1 {
            cnts[(s[i] as u8 - 'a' as u8) as usize] += cnt;
        }
    }
    cnts
}

fn main() {
    let s = read::<String>().chars().collect::<Vec<char>>();
    let l = read::<usize>() - 1;
    let r = read::<usize>();
    let cnts = solve(&s, l, r);
    for i in 0..26 {
        if i != 0 {
            print!(" ");
        }
        print!("{}", cnts[i]);
    }
    println!("");
}

#[test]
fn test() {
    solve(&vec!['a'; 200000], 10, 10000000000000000);
}


Measured memory_bytes: 12540