class DSU:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [1] * n
        self.components = n
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    
    def union(self, x, y):
        rootX = self.find(x)
        rootY = self.find(y)
        if rootX != rootY:
            if self.rank[rootX] > self.rank[rootY]:
                self.parent[rootY] = rootX
            elif self.rank[rootX] < self.rank[rootY]:
                self.parent[rootX] = rootY
            else:
                self.parent[rootY] = rootX
                self.rank[rootX] += 1
            self.components -= 1
        return self.components

def minimum_string_length_for_components(s):
    n = len(s)
    results = [0] * n
    for k in range(1, n + 1):
        dsu = DSU(n)
        substring_lengths = {}

        for length in range(1, n + 1):
            for start in range(n - length + 1):
                substr = s[start:start + length]
                if substr not in substring_lengths:
                    substring_lengths[substr] = length
                
                for i in range(start, start + length - 1):
                    dsu.union(i, i + 1)
        
        for substr in sorted(substring_lengths.keys(), key=lambda x: substring_lengths[x]):
            length = substring_lengths[substr]
            current_components = dsu.components
            if current_components <= k:
                results[k - 1] = length
                break
            for start in range(n - length + 1):
                if s[start:start + length] == substr:
                    for i in range(start, start + length - 1):
                        dsu.union(i, i + 1)
    
    return results

# Read input
import sys
input = sys.stdin.read
data = input().strip()

# Calculate and print results
results = minimum_string_length_for_components(data)
print(" ".join(map(str, results)))