from itertools import zip_longest, count, permutations
import re

def uniqc(xs):
    seen = set((None,))
    return [''.join('' if c in seen else seen.add(c) or c for c in w)
            for w in xs]

def solve(q):
    def term(var):
        return '+'.join("a[{0}]*{1}".format(index[x], 10**i)
                        for i, x in enumerate(reversed(var)))

    variables = re.findall(r'\w+', q)
    steps = uniqc(zip_longest(*variables))
    index = dict(zip(''.join(steps), count()))
    limits = [sum(int(10**(e - 1)) for e in t)
              for t in [[x - i for x in [len(v) for v in variables]]
                        for i in range(len(steps))]]
    qq = re.sub('^([^=]+)=+(.*)$', r'(\1)-(\2)', q)
    e = 'lambda a: abs(%s)' % re.sub(r'\w+', lambda m: term(m.group()), qq)
    distance = eval(e)
    distancex = lambda a: distance((a + (5,)*10)[:len(index)])

    def advance(steps, limits, c, r):
        if not steps:
            if not distance(c):
                yield re.sub(r'\w', lambda m: str(c[index[m.group()]]), q)
        elif not steps[0]:
            yield from advance(steps[1:], limits[1:], c, r)
        else:
            xs = r if c else set(range(1,10))
            ps = (c + p for p in permutations(xs, len(steps[0])))
            for d, p in sorted((distancex(p), p) for p in ps):
                if d < limits[0]:
                    yield from advance(steps[1:], limits[1:], p, r - set(p))

    yield from advance(steps, limits, (), set(range(10)))

testcase = '''
SEND + MORE = MONEY
APPLE + GRAPE = CHERRY
KYOTO + OSAKA = TOKYO
AOMORI + SAPPORO = FUKUOKA
KOCHI + OSAKA = NAGOYA
OKAYAMA + WAKAYAMA = KANAZAWA
FUKUOKA + NAGANO = YOKOHAMA
KAMAKURA + MORIOKA = NAGASAKI
KUMAMOTO + TOTTORI = WAKAYAMA
OKAYAMA + WAKAYAMA = YAMAGATA
TOTTORI + YAMAGATA = YOKOHAMA
'''
for case in testcase.strip().splitlines():
    print(next(solve(case)))