Problem: Palindromic characteristics of string s with length |s| is a sequence of |s| integers, where k-th number is the total number of non-empty substrings of s which are k-palindromes.

A string is 1-palindrome if and only if it reads the same backward as forward.

A string is k-palindrome (k > 1) if and only if: 

  1. Its left half equals to its right half. 
  2. Its left and right halfs are non-empty (k - 1)-palindromes. 



The left half of string t is its prefix of length ⌊|t| / 2⌋, and right half — the suffix of the same length. ⌊|t| / 2⌋ denotes the length of string t divided by 2, rounded down.

Note that each substring is counted as many times as it appears in the string. For example, in the string "aaa" the substring "a" appears 3 times.

Input

The first line contains the string s (1 ≤ |s| ≤ 5000) consisting of lowercase English letters.

Output

Print |s| integers — palindromic characteristics of string s.

Examples

Input

abba


Output

6 1 0 0 


Input

abacaba


Output

12 4 1 0 0 0 0 

Note

In the first example 1-palindromes are substring «a», «b», «b», «a», «bb», «abba», the substring «bb» is 2-palindrome. There are no 3- and 4-palindromes here.

Solution (in JAVA):

Solution:
import java.io.*;

public class D {

  private static final String REGEX = " ";
  private static final Boolean DEBUG = false;
  private static final String FILE_NAME = "input.txt";


  public static void main(String[] args) throws IOException {
    if (DEBUG) {
      generate();
    }
    Solver solver = new Solver();
    solver.readData();
    solver.solve();
    solver.print();
  }

  private static void generate() throws IOException {
//    FileWriter writer = new FileWriter("input.txt");
//    writer.close();
  }

  private static class Solver {
    private StringBuilder myStringBuilder = new StringBuilder();
    String s;
    int n;
    int[][] pow;
    int[] result;

    void readData() throws IOException {
      Scanner scanner = new Scanner();
      s = scanner.nextLine();
      n = s.length();
      pow = new int[n][n];
      result = new int[n + 1];
      scanner.close();
    }

    void solve() {
      for (int length = 0; length < n; length++) {
        for (int i = 0; i < n - length; i++) {
          int j = i + length;
          if (i == j) {
            pow[i][j] = 1;
            result[1]++;
          } else {
            if (s.charAt(j) == s.charAt(i)) {
              if (j == i + 1) {
                pow[i][j] = 2;
                result[2]++;
              } else {
                if (pow[i + 1][j - 1] > 0) {
                  int k = pow[i][i + (j - i + 1) / 2 - 1];
                  pow[i][j] = k + 1;
                  result[k + 1]++;
                }
              }
            }
          }

        }
      }
      int current = result[n];
      for (int i = n - 1; i >= 1; i--) {
        result[i] += current;
        current = result[i];
      }
      for (int i = 1; i <= n; i++) {
        out(result[i]);
        out(' ');
      }
    }


    void print() {
      System.out.println(myStringBuilder);
    }


    void out(Object object) {
      myStringBuilder.append(object);
    }

    void out(String string) {
      myStringBuilder.append(string);
    }

    public void out(boolean b) {
      myStringBuilder.append(b);
    }

    public void out(char c) {
      myStringBuilder.append(c);
    }

    public void out(int i) {
      myStringBuilder.append(i);
    }

    public void out(long lng) {
      myStringBuilder.append(lng);
    }

    public void out(float f) {
      myStringBuilder.append(f);
    }

    public void out(double d) {
      myStringBuilder.append(d);
    }

    public void newLine() {
      myStringBuilder.append("\n");
    }

    @SuppressWarnings("SameParameterValue")
    int[] splitInteger(String string, int n) {
      final String[] split = string.split(REGEX, n);
      int[] result = new int[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Integer.parseInt(split[i]);
      }
      return result;
    }

    public int[] splitInteger(String string) {
      return splitInteger(string, 0);
    }


    @SuppressWarnings("SameParameterValue")
    long[] splitLong(String string, int n) {
      final String[] split = string.split(REGEX, n);
      long[] result = new long[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Long.parseLong(split[i]);
      }
      return result;
    }

    public long[] splitLong(String string) {
      return splitLong(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    double[] splitDouble(String string, int n) {
      final String[] split = string.split(REGEX, n);
      double[] result = new double[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Double.parseDouble(split[i]);
      }
      return result;
    }

    public double[] splitDouble(String string) {
      return splitDouble(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    String[] splitString(String string, int n) {
      return string.split(REGEX, n);
    }

    public String[] splitString(String string) {
      return splitString(string, 0);
    }

    public int max(int a, int b) {
      return Math.max(a, b);
    }

    public int max(int[] arr) {
      int max = Integer.MIN_VALUE;
      for (int x : arr) {
        max = max(max, x);
      }
      return max;
    }

    public long max(long a, long b) {
      return Math.max(a, b);
    }

    public int min(int a, int b) {
      return Math.min(a, b);
    }

    public long min(long a, long b) {
      return Math.min(a, b);
    }

    public double max(double a, double b) {
      return Math.max(a, b);
    }

    public double min(double a, double b) {
      return Math.min(a, b);
    }

    private final static int MOD = 1000000009;

    int multMod(int a, int b) {
      return ((a % MOD) * (b % MOD)) % MOD;
    }

    int sumMod(int a, int b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }

    long multMod(long a, long b) {
      return ((a % MOD) * (b % MOD)) % MOD;
    }

    long sumMod(long a, long b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }

  }

  private static class Scanner {
    private int currentIndex = 0;
    private String[] objects;
    private final BufferedReader myReader;
    private Computable<Character> charComputer;
    private Computable<Double> doubleComputer;
    private Computable<Integer> intComputer;
    private Computable<Long> longComputer;

    Scanner() throws FileNotFoundException {
      InputStream in = DEBUG ? new FileInputStream(FILE_NAME) : System.in;
      myReader = new BufferedReader(new InputStreamReader(in));
      charComputer = () -> objects[currentIndex].charAt(0);
      doubleComputer = () -> Double.parseDouble(objects[currentIndex]);
      intComputer = () -> Integer.parseInt(objects[currentIndex]);
      longComputer = () -> Long.parseLong(objects[currentIndex]);
    }

    String nextLine() throws IOException {
      objects = null;
      currentIndex = 0;
      return myReader.readLine();
    }

    int nextInt() throws IOException {
      return next(intComputer);

    }

    long nextLong() throws IOException {
      return next(longComputer);

    }

    double nextDouble() throws IOException {
      return next(doubleComputer);

    }

    char nextChar() throws IOException {
      return next(charComputer);
    }

    <T> T next(Computable<T> computer) throws IOException {
      T result;
      if (objects == null || currentIndex >= objects.length) {
        String s = myReader.readLine();
        objects = s.split(" ");
        currentIndex = 0;
      }
      result = computer.compute();
      currentIndex++;
      return result;
    }

    interface Computable<T> {
      T compute();
    }

    public void close() throws IOException {
      myReader.close();
    }
  }

}