#!/bin/env python3

import re


class Molecule(object):
    SPLIT_RE = re.compile(
        '(?P<element>[A-Z][a-z]?)(?P<count>\d*)|'
        '(?P<open>\()|'
        '\)(?P<close>\d+)|'
        '.'
    )

    def __init__(self, *, elements):
        self._elements = elements

    @classmethod
    def from_string(cls, s):
        molecule, remainder = cls.from_tokens(
            list(cls.SPLIT_RE.finditer(s))
        )
        if remainder is not None:
            raise ValueError
        return molecule

    @classmethod
    def from_tokens(cls, tokens):
        molecule = cls(elements=dict())
        while tokens:
            for ind, t in enumerate(tokens):
                if t.group('element'):
                    molecule += cls.from_token(t)
                elif t.group('open'):
                    next_, remainder = cls.from_tokens(tokens[ind+1:])
                    next_count = int(remainder[0].group('close'))
                    next_ *= next_count
                    molecule += next_
                    tokens = remainder[1:]
                    break
                elif t.group('close'):
                    return molecule, tokens[ind:]
                else:
                    raise ValueError
            else:
                tokens = False
        return molecule, None

    @classmethod
    def from_token(cls, token):
        return cls(
            elements={
                token.group('element'): int('0'+token.group('count')) or 1
            }
        )

    def __mul__(self, other):
        if isinstance(other, int):
            return Molecule(
                elements={
                    ele: count * other
                    for ele, count in self._elements.items()
                }
            )
        else:
            raise TypeError

    def __add__(self, other):
        if isinstance(other, Molecule):
            elements = self._elements.copy()
            for ele, count in other._elements.items():
                elements[ele] = elements.get(ele, 0) + count
            return Molecule(
                elements=elements
            )
        elif other is None:
            return self
        else:
            raise TypeError

    def __str__(self):
        return '\n'.join(
            '{k} -> {v}'.format(k=k, v=v)
            for k, v in self._elements.items()
        )


def main():
    import sys
    for line in sys.stdin:
        m = Molecule.from_string(line)
        print(m)


if __name__ == '__main__':
    main()