class Parser:
    def __init__(self, s, d):
        self.s = s
        self.pos = 0
        self.d = d

    def parse_expression(self):
        res = self.parse_term()
        while self.pos < len(self.s) and self.s[self.pos] == '+':
            self.pos += 1
            term = self.parse_term()
            res = self.add_poly(res, term)
        return res

    def parse_term(self):
        res = self.parse_factor()
        while self.pos < len(self.s) and self.s[self.pos] == '*':
            self.pos += 1
            factor = self.parse_factor()
            res = self.multiply_poly(res, factor)
        return res

    def parse_factor(self):
        c = self.s[self.pos]
        if c == 'd':
            self.pos += 1
            if self.pos >= len(self.s) or self.s[self.pos] != '{':
                raise ValueError("Expected '{' after 'd'")
            self.pos += 1
            expr_poly = self.parse_expression()
            if self.pos >= len(self.s) or self.s[self.pos] != '}':
                raise ValueError("Expected '}' after expression")
            self.pos += 1
            return self.derivative(expr_poly)
        elif c == 'x':
            self.pos += 1
            return self.create_x_poly()
        elif c.isdigit():
            num = int(c)
            self.pos += 1
            return self.create_number_poly(num)
        else:
            raise ValueError(f"Unexpected character: {c} at pos {self.pos}")

    def add_poly(self, a, b):
        res = [0] * (self.d + 1)
        for i in range(self.d + 1):
            res[i] = a[i] + b[i]
        return res

    def multiply_poly(self, a, b):
        res = [0] * (self.d + 1)
        for i in range(self.d + 1):
            if a[i] == 0:
                continue
            for j in range(self.d + 1):
                if b[j] == 0:
                    continue
                k = i + j
                if k <= self.d:
                    res[k] += a[i] * b[j]
        return res

    def derivative(self, poly):
        res = [0] * (self.d + 1)
        for i in range(1, self.d + 1):
            res[i-1] = poly[i] * i
        return res

    def create_x_poly(self):
        poly = [0] * (self.d + 1)
        if self.d >= 1:
            poly[1] = 1
        return poly

    def create_number_poly(self, num):
        poly = [0] * (self.d + 1)
        poly[0] = num
        return poly

def main():
    import sys
    input = sys.stdin.read().split()
    n = int(input[0])
    d = int(input[1])
    s = input[2]
    parser = Parser(s, d)
    try:
        poly = parser.parse_expression()
    except:
        print("0 " * (d + 1))
        return
    print(' '.join(map(str, poly)))

if __name__ == "__main__":
    main()