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 0 s.       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 (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

import numpy as np

S = readline().rstrip()
l,r = map(int,read().split())

def double_naive(S):
    L = len(S)
    for i in range(1,L+1):
        T = S[:i] * 2
        if len(T) > L and T[:L] == S:
            return T

def Z_algorithm(S):
    
    N=len(S)
    arr = [0]*N
    arr[0] = N
    i,j = 1,0
    while i<N:
        while i+j<N and S[j]==S[i+j]:
            j += 1
        arr[i]=j
        if not j:
            i += 1
            continue
        k = 1
        while i+k<N and k+arr[k]<j:
            arr[i+k] = arr[k]
            k += 1
        i += k; j -= k
    return arr

def F(S):
    N = len(S)
    opt_len = N
    Z = Z_algorithm(S)
    for x in range(N//2+1,N):
        z = Z[x]
        if x + z >= N:
            opt_len = x
            break
    return S[:opt_len] * 2

S = F(S)
S = F(S)
T = F(S)
S = S[:len(S)//2]
T = T[:len(T)//2]

S = np.array(list(S)) - ord('a')
T = np.array(list(T)) - ord('a')



L = [len(S), len(T)]
for _ in range(100):
    L.append(L[-1] + L[-2])
ctr = [np.bincount(S,minlength=26), np.bincount(T,minlength=26)]
for _ in range(100):
    ctr.append(ctr[-1] + ctr[-2])

def get_dist(N,R):
    
    if N == 0:
        return np.bincount(S[:R],minlength=26)
    if N == 1:
        return np.bincount(T[:R],minlength=26)
    if L[N-1] >= R:
        return get_dist(N-1,R)
    return ctr[N-1] + get_dist(N-2,R-L[N-1])

c = get_dist(99,r) - get_dist(99,l-1)

print(*c)