import sys
 
INF = 10 ** 9
 
def build_prefix_function(p):
    m = len(p)
    pi = [0] * m
    for i in range(1, m):
        j = pi[i - 1]
        while j > 0 and p[i] != p[j]:
            j = pi[j - 1]
        if p[i] == p[j]:
            j += 1
        pi[i] = j
    return pi
 
def build_transitions(p, pi):
    m = len(p)
    trans = [[0, 0] for _ in range(m + 1)]   # state 0..m
    for s in range(m + 1):
        for bit in (0, 1):
            if s == m:
                # after a full match we are already at fallback,
                # but we never really stay in state m,
                # this entry will never be used.
                ns = s
            else:
                j = s
                while j > 0 and (p[j] != str(bit)):
                    j = pi[j - 1]
                if p[j] == str(bit):
                    j += 1
                ns = j
            trans[s][bit] = ns
    return trans
 
def solve() -> None:
    data = sys.stdin.read().strip().split()
    if not data:
        return
    it = iter(data)
    n = int(next(it))
    m = int(next(it))
    a = next(it).strip()
    b = next(it).strip()
 
    N = n - m + 1                     # maximal possible occurrences
    pi = build_prefix_function(b)
    trans = build_transitions(b, pi)
    fallback = pi[m - 1] if m > 0 else 0
 
    # dp[j][s]  for the current processed prefix
    dp = [[INF] * m for _ in range(N + 1)]
    dp[0][0] = 0
 
    a_bits = [int(ch) for ch in a]
 
    for i in range(n):
        # next layer
        dp2 = [[INF] * m for _ in range(N + 1)]
        max_j = min(N, i + 1)          # at most one new occurrence per character
        for j in range(max_j + 1):
            row = dp[j]
            for s in range(m):
                cur = row[s]
                if cur == INF:
                    continue
                for bit in (0, 1):
                    cost = cur + (bit != a_bits[i])
                    ns = trans[s][bit]
                    add = 0
                    if ns == m:
                        add = 1
                        ns = fallback
                    nj = j + add
                    if nj > N:
                        continue
                    if cost < dp2[nj][ns]:
                        dp2[nj][ns] = cost
        dp = dp2
 
    out = []
    for k in range(N + 1):
        best = min(dp[k])
        out.append(str(best if best < INF else -1))
    sys.stdout.write(' '.join(out))
 
if __name__ == "__main__":
    solve()