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 Java8 (OpenJDK 1.8.0) (judge verdict: Runtime Error)

import java.util.*;
import java.io.*;
import java.math.*;

public class Main{

  static long[] fact;
  static long m = 1_000_000_007L;

  static long modPow(long base, long exp, long mod){
    long ans = 1L;
    while (exp != 0) {
      if (exp % 2 != 0)
        ans = ans * base % mod;
      exp >>= 1;
      base %= mod;
      base = base * base % mod;
    }

    return ans;
  }

  static long nck(int n, int k){
    return fact[n]*modPow(fact[k], m-2, m)%m*modPow(fact[n-k], m-2, m)%m;
  }

  public static void main(String[] args) throws IOException {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    Integer n = Integer.parseInt(in.readLine());
    Integer[] a = Arrays.stream(in.readLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
    long cnt = 0;
    int deplLeft=0, deplRight=0;

    Set<Integer> set = new HashSet<>();

    for(int i=0;i<n+1;i++){
      if(set.contains(a[i])){
        for(int j=0;j<i;j++){
          if(a[i]==a[j]){
            deplLeft = j;
            deplRight = i;
          }
        }
      }else{
        set.add(a[i]);
      }
    }

    fact = new long[n+2];

    fact[0] = 1;
    for(int i=1;i<n+2;i++){
      fact[i] = fact[i-1] * i % m;
    }

    StringBuffer sb = new StringBuffer();
    long b,c;
    for(int i=0;i<n+1;i++){
      b = nck(n+1, i+1);

      if(deplLeft+n-deplRight-i>=0){
        c = nck(deplLeft+n-deplRight, i);
      } else {
        c = 0;
      }
      // System.out.println(b);
      // System.out.println(c);
      // System.out.println();
      sb.append((b - c + m) % m);
      sb.append("\n");
    }
    System.out.print(sb.toString());
  }
}