Problem:
Score : 1100 points

Problem Statement

We will call a string that can be obtained by concatenating two equal strings an even string.
For example, xyzxyz and aaaaaa are even, while ababab and xyzxy are not.

For a non-empty string S, we will define f(S) as the shortest even string that can be obtained by appending one or more characters to the end of S.
For example, f(abaaba)=abaababaab.
It can be shown that f(S) is uniquely determined for a non-empty string S.

You are given an even string S consisting of lowercase English letters.
For each letter in the lowercase English alphabet, find the number of its occurrences from the l-th character through the r-th character of f^{10^{100}} (S).

Here, f^{10^{100}} (S) is the string f(f(f( ... f(S) ... ))) obtained by applying f to S 10^{100} times.

Constraints

2 \leq |S| \leq 2\times 10^5

1 \leq l \leq r \leq 10^{18}

S is an even string consisting of lowercase English letters.

l and r are integers.

Input

Input is given from Standard Input in the following format:

S
l r

Output

Print 26 integers in a line with spaces in between.
The i-th integer should be the number of the occurrences of the i-th letter in the lowercase English alphabet from the l-th character through the r-th character of f^{10^{100}} (S).

Sample Input 1

abaaba
6 10

Sample Output 1

3 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Since f(abaaba)=abaababaab, the first ten characters in f^{10^{100}}(S) is also abaababaab. Thus, the sixth through the tenth characters are abaab. In this string, a appears three times, b appears twice and no other letters appear, and thus the output should be 3 and 2 followed by twenty-four 0s.

Sample Input 2

xx
1 1000000000000000000

Sample Output 2

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1000000000000000000 0 0

Sample Input 3

vgxgpuamkvgxgvgxgpuamkvgxg
1 1000000000000000000

Sample Output 3

87167725689669676 0 0 0 0 0 282080685775825810 0 0 0 87167725689669676 0 87167725689669676 0 0 87167725689669676 0 0 0 0 87167725689669676 141040342887912905 0 141040342887912905 0 0

Solution in Rust (1.15.1) (judge verdict: Accepted)

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);
}