class Node:
    def evaluate(self, d):
        pass

class ConstantNode(Node):
    def __init__(self, value):
        self.value = value

    def evaluate(self, d):
        coeff = [0] * (d + 1)
        coeff[0] = self.value
        return coeff

class XNode(Node):
    def evaluate(self, d):
        coeff = [0] * (d + 1)
        if d >= 1:
            coeff[1] = 1
        return coeff

class AddNode(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def evaluate(self, d):
        left_coeff = self.left.evaluate(d)
        right_coeff = self.right.evaluate(d)
        return [left_coeff[i] + right_coeff[i] for i in range(d + 1)]

class MultiplyNode(Node):
    def __init__(self, left, right):
        self.left = left
        self.right = right

    def evaluate(self, d):
        left_coeff = self.left.evaluate(d)
        right_coeff = self.right.evaluate(d)
        result = [0] * (d + 1)
        for a in range(d + 1):
            if left_coeff[a] == 0:
                continue
            for b in range(d + 1):
                if right_coeff[b] == 0:
                    continue
                if a + b <= d:
                    result[a + b] += left_coeff[a] * right_coeff[b]
        return result

class DerivNode(Node):
    def __init__(self, child):
        self.child = child

    def evaluate(self, d):
        child_coeff = self.child.evaluate(d)
        deriv_coeff = [0] * (d + 1)
        for i in range(d + 1):
            if i + 1 <= d:
                deriv_coeff[i] = (i + 1) * child_coeff[i + 1]
            else:
                deriv_coeff[i] = 0
        return deriv_coeff

def parse_expression(s, pos=0):
    node, pos = parse_term(s, pos)
    while pos < len(s) and s[pos] == '+':
        pos += 1
        next_node, pos = parse_term(s, pos)
        node = AddNode(node, next_node)
    return node, pos

def parse_term(s, pos):
    node, pos = parse_factor(s, pos)
    while pos < len(s) and s[pos] == '*':
        pos += 1
        next_node, pos = parse_factor(s, pos)
        node = MultiplyNode(node, next_node)
    return node, pos

def parse_factor(s, pos):
    if pos < len(s) and s[pos] == 'd' and pos + 1 < len(s) and s[pos + 1] == '{':
        pos += 2
        child, pos = parse_expression(s, pos)
        if pos >= len(s) or s[pos] != '}':
            raise ValueError("Missing closing brace")
        pos += 1
        return DerivNode(child), pos
    else:
        return parse_primary(s, pos)

def parse_primary(s, pos):
    if pos >= len(s):
        raise ValueError("Unexpected end of input")
    c = s[pos]
    if c == 'x':
        return XNode(), pos + 1
    elif c.isdigit():
        val = int(c)
        return ConstantNode(val), pos + 1
    else:
        raise ValueError(f"Unexpected character {c} at position {pos}")

# Read input
n = int(input())
d = int(input())
s = input().strip()

# Parse the expression
ast, pos = parse_expression(s, 0)
if pos != len(s):
    raise ValueError("Invalid input")

# Evaluate and output
result = ast.evaluate(d)
print(' '.join(map(str, result)))