In this problem you will write a simple generator of Brainfuck (https://en.wikipedia.org/wiki/Brainfuck) calculators.

You are given an arithmetic expression consisting of integers from 0 to 255 and addition/subtraction signs between them. Output a Brainfuck program which, when executed, will print the result of evaluating this expression.

We use a fairly standard Brainfuck interpreter for checking the programs:



 30000 memory cells.

 memory cells store integers from 0 to 255 with unsigned 8-bit wraparound.

 console input (, command) is not supported, but it's not needed for this problem.


-----Input-----

The only line of input data contains the arithmetic expression. The expression will contain between 2 and 10 operands, separated with arithmetic signs plus and/or minus. Each operand will be an integer between 0 and 255, inclusive. The calculations result is guaranteed to be an integer between 0 and 255, inclusive (results of intermediary calculations might be outside of these boundaries).


-----Output-----

Output a Brainfuck program which, when executed, will print the result of evaluating this expression. The program must be at most 5000000 characters long (including the non-command characters), and its execution must be complete in at most 50000000 steps.


-----Examples-----
Input
2+3

Output
++>
+++>
<[<+>-]<
++++++++++++++++++++++++++++++++++++++++++++++++.

Input
9-7

Output
+++++++++>
+++++++>
<[<->-]<
++++++++++++++++++++++++++++++++++++++++++++++++.



-----Note-----

You can download the source code of the Brainfuck interpreter by the link http://assets.codeforces.com/rounds/784/bf.cpp. We use this code to interpret outputs.

Source: codeforces | Difficulty: HARD


Solutions:
s = input().strip()
s = str(eval(s))
for c in s:
	print('[-]')
	print('+' * ord(c))
	print('.')


s = input()
cur = 0
tmp = []
a = []
for i in s:
	if i == '+' or i == '-':
		a.append(cur)
		tmp.append(i)
		cur = 0
	else:
		cur = cur * 10 + (ord(i) - ord('0'))
a.append(cur)
print('+' * a[0] + '>')
for i in range(len(tmp)):
	print('+' * a[i + 1] + '>')
	if tmp[i] == '+':
		print('<[<+>-]<')
	else:
		print('<[<->-]<')
	if i < len(tmp) - 1:
		print('>')
print('[>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<[.[-]<]<')


x = str(eval(input()))
print(x)
for c in x:
	print('+' * ord(c), '.')
	print('[-]')


str = input()
res = eval(str)
a = res // 100
b = res // 10 % 10
c = res % 10

def getans(x: int):
	for i in range(0, 48 + x):
		print('+', end='')
	print('.>', end='')
if a != 0:
	getans(a)
if b != 0:
	getans(b)
getans(c)


a = eval(input())
s = str(a)
for i in s:
	b = ''
	for j in range(ord(i)):
		b += '+'
	b += '.>'
	print(b)


import sys
s = sys.stdin.readline().strip()
s = '+' + s + '+'
sps = [i for (i, c) in enumerate(s) if c in '+-']
res = sum((int(s[i0:i1]) for (i0, i1) in zip(sps[:-1], sps[1:])))
print('.>\n'.join(('+' * ord(r) for r in str(res))) + '.')


inp = input()
exec('calc_result = {}'.format(inp))
s = str(calc_result)
for ch in s:
	print('[-]', end='')
	print('+' * ord(ch), end='')
	print('.', end='')


for n in str(eval(input())):
	for _ in range(ord(n)):
		print('+', sep='', end='')
	print('.>')


x = input()
x = x + '.'
numbs = '1234567890'
operator = []
numbers = []
something = ''
for y in x:
	if numbs.find(y) != -1:
		something = something + y
	elif y == '.':
		numbers.append(something)
	else:
		numbers.append(something)
		operator.append(y)
		something = ''
result = int(numbers[0])
for y in range(len(numbers) - 1):
	if operator[y] == '+':
		result = result + int(numbers[y + 1])
	else:
		result = result - int(numbers[y + 1])
result = str(result)
print(result)
bf = '++++++[>+++++ +++<-]>'
ans = ''
for y in range(len(result)):
	something = bf
	for z in range(int(result[y])):
		something = something + '+'
	something = something + '.'
	ans = ans + something + '>'
print(ans)


x = eval(input())
s = str(x)
res = ''
for c in s:
	res += '+' * ord(c) + '.>'
print(res)


a = input()
if eval(a) // 100 != 0:
	for i in range(0, 48 + eval(a) // 100):
		print('+', end='')
	print('.>', end='')
if eval(a) % 100 // 10 != 0:
	for i in range(0, 48 + eval(a) % 100 // 10):
		print('+', end='')
	print('.>', end='')
for i in range(0, 48 + eval(a) % 10):
	print('+', end='')
print('.>', end='')


n = str(eval(input().strip()))
res = ''
for c in n:
	a = ord(c)
	res += '+' * a + '.[-]'
print(res)


ans = str(eval(input()))
for x in ans:
	y = int(x) + 48
	print('+' * y + '.>')


n = eval(input())
for c in str(n):
	print('>')
	print('+' * ord(c) + '.')


x = input()
y = eval(x)
y = str(y)
now = 0
res = ''
for c in y:
	z = ord(c)
	while now < z:
		now += 1
		res += '+'
	while now > z:
		now -= 1
		res += '-'
	res += '.'
print(res)


x = int(eval(input()))
z = str(x)
for i in range(len(z)):
	for j in range(ord(z[i])):
		print('+', sep='', end='')
	print('.>')


s = input()
v = eval(s)
if v // 100 > 0:
	print('+' * (ord('0') + v // 100) + '.>')
v %= 100
if v // 10 > 0:
	print('+' * (ord('0') + v // 10) + '.>')
v %= 10
print('+' * (ord('0') + v) + '.>')


i = str(eval(input()))
for s in i:
	print('+' * int(s) + '++++++++++++++++++++++++++++++++++++++++++++++++.>')


a = input()
n = tuple(map(int, a.replace('-', '+').split('+')))
o = [o == '+' for o in a if not o.isdigit()]
print('+' * n[0] + '>')
for i in range(1, len(n)):
	print('+' * n[i] + '>')
	s = '<[<+>-]' if o[i - 1] else '<[<->-]'
	print(s + '<' if i == len(n) - 1 else s)
print('>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[- <+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++ <]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<')


x = input()
result = eval(x)

def printchar(x):
	for i in range(x):
		print('+', end='')
	for i in range(48):
		print('+', end='')
	print('.', end='')
	for i in range(48):
		print('-', end='')
	for i in range(x):
		print('-', end='')
	print()
for c in str(result):
	printchar(int(c))


a = eval(input())
for c in str(a):
	val = ord(c)
	print('+' * val + '.' + '-' * val)


x = eval(input())
print('++++++++++++++++++++++++++++++++++++++++++++++++')
s = str(x)
for i in range(len(s)):
	c = s[i]
	q = 0
	while str(q)[0] < c:
		print('+')
		q += 1
	print('.')
	while str(q)[0] > '0':
		print('-')
		q -= 1


S = input()
val = str(eval(S))
ans = ''
for c in val:
	for t in range(ord(c)):
		ans += '+'
	ans += '.>'
print(ans)


s = '{}'.format(eval(input()))
print('++++++++++++++++++++++++++++++++++++++++++++++++')
for i in range(len(s)):
	x = int(s[i], 10)
	for j in range(x):
		print('+', end='')
	print('.', end='')
	for j in range(x):
		print('-', end='')


s = input()
x = str(eval(s))
print('+' * 48, end='')
for i in range(len(x)):
	if i == 0:
		print('+' * int(x[i]) + '.', end='')
	else:
		d = int(x[i]) - int(x[i - 1])
		if d > 0:
			print('+' * d + '.', end='')
		else:
			print('-' * -d + '.', end='')


print('\n'.join(('>' + '+' * (48 + int(x)) + '.' for x in str((eval(input()) + 256 * 100) % 256))))


for digit in str(eval(input())):
	print('+' * ord(digit) + '.>')


x = str(eval(input()))
for t in x:
	for i in range(ord(t)):
		print('+', end='')
	print('.>')


def p(x):
	print('[-]' + '+' * x + '.')
a = str(eval(input()))
for i in a:
	p(ord(i))


s = input()
val = str(eval(s))
print('+' * 48)
lastDigit = '0'
for digit in val:
	delta = ord(digit) - ord(lastDigit)
	if delta != 0:
		print(('+' if delta > 0 else '-') * abs(delta))
	print('.')
	lastDigit = digit


s = map(int, str(eval(input())))
print('++++++++++++++++++++++++++++++++++++++++++++++++', end='')
for c in s:
	print('+' * c + '.' + '-' * c, end='')
print()


for i in str(eval(input())):
	print('+' * ord(i), end='.>')


line = input()
line = line.replace('+', ' +')
line = line.replace('-', ' -')
val = 0
for tok in line.split():
	val += int(tok)
print('++++++++++++++++++++++++++++++++++++++++++++++++')
li = []

def foo(num):
	if num < 10:
		li.append(num)
		return
	foo(num // 10)
	li.append(num % 10)
foo(val)
for d in li:
	print('+' * d, '.', '-' * d)


s = input().strip()
k = eval(s)
if k // 100:
	print('++++++++++++++++++++++++++++++++++++++++++++++++', '+' * (k // 100), '.', '>', sep='')
if k // 10:
	print('++++++++++++++++++++++++++++++++++++++++++++++++', '+' * (k // 10 % 10), '.', '>', sep='')
print('++++++++++++++++++++++++++++++++++++++++++++++++', '+' * (k % 10), '.', sep='')


OP = '+-'

def get_target():
	cmd = input()
	nums = []
	ops = []
	buf = []
	for c in cmd:
		if c in OP:
			nums.append(int(''.join(buf)))
			ops.append(c)
			buf = []
		else:
			buf.append(c)
	nums.append(int(''.join(buf)))
	return (nums, ops)

def solve(nums, ops):
	ans = nums[0]
	nums = nums[1:]
	for (i, op) in enumerate(ops):
		if op == '-':
			ans -= nums[i]
		else:
			ans += nums[i]
	return ans

def main():
	ans = eval(input())
	out = list(map(int, str(ans)))
	for (i, x) in enumerate(out):
		print('+' * (x + 48) + '.>')
main()


str = input()
num = int(eval(str))
res = ''
if num == 0:
	dig = 48
	cur = ''
	for i in range(0, dig):
		cur = cur + '+'
	cur = cur + '.'
	for i in range(0, dig):
		cur = cur + '-'
	res = cur + res
while num > 0:
	dig = num % 10
	num = num // 10
	dig = dig + 48
	cur = ''
	for i in range(0, dig):
		cur = cur + '+'
	cur = cur + '.'
	for i in range(0, dig):
		cur = cur + '-'
	res = cur + res
print(res)


n = eval(input())
z = ord('0')
for i in range(z):
	print('+', end='')
print('')
if n >= 100:
	d = 100
elif n >= 10:
	d = 10
else:
	d = 1
while d > 0:
	x = n // d % 10 + ord('0')
	while x > z:
		print('+', end='')
		z += 1
	while x < z:
		print('-', end='')
		z -= 1
	print('.')
	d //= 10


for c in str(eval(input())):
	print('+' * ord(c) + '.>', end='')


i = eval(input())
print('>' + '+' * i + '[>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<[.[-]<]<')


p = str(eval(input().replace('/', '//')))
lastnum = 0
for x in p:
	num = ord(x)
	if num > lastnum:
		print('+' * (num - lastnum) + '.')
	else:
		print('-' * (lastnum - num) + '.')
	lastnum = num


s = str(eval(input()))
for i in s:
	print('+' * (int(i) + 48), end='.>')


s = input()
s = str(eval(s))
p = '++++++[>++++++++<-]>'
print(p, end='')
pre = 0
for dig in s:
	digit = int(dig)
	if digit == pre:
		print('.', end='')
	elif digit < pre:
		for i in range(pre - digit):
			print('-', end='')
		print('.', end='')
	else:
		for i in range(digit - pre):
			print('+', end='')
		print('.', end='')
	pre = digit


import re
s = input()
ops = re.split('([+-])', s)
assert len(ops) % 2 == 1
ops = ['+'] + ops
total = 0
for i in range(0, len(ops), 2):
	if ops[i] == '+':
		total += int(ops[i + 1])
	elif ops[i] == '-':
		total -= int(ops[i + 1])
	else:
		assert False
for b in bytes(str(total), 'ascii'):
	print('+' * b + '.>')


n = str(eval(input()))
for i in n:
	print('+' * ord(i) + '.>')


k = eval(input())
o = ''
for i in str(k):
	a = ord(i)
	o += '+' * a + '.[-]'
print(o)


import re
s = input() + '+'
ss = 0
neg = False
for (i, ch) in enumerate(s):
	if ch == '-' and i == 0:
		ss = -1
	elif ch == '+' or ch == '-':
		if neg:
			print('-' * ss, end='')
		else:
			print('+' * ss, end='')
		ss = 0
		neg = ch == '-'
	else:
		ss = ss * 10 + int(ch)
print('>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]')


res = ''
for c in str(eval(input())):
	res += '+' * ord(c) + '.>'
print(res)


print(''.join(('+' * (48 + int(x)) + '.>' for x in str(eval(input())))))


res = str(eval(input()))
for c in res:
	dif = int(c)
	for i in range(48 + dif):
		print('+')
	print('.>')


a = input()
b = eval(a)
print(b)
for i in str(b):
	print('+' * ord(i) + '.>')


strs = input()
a = 0
exec('a = {0}'.format(strs))
num = str(a)
for x in num:
	print('>')
	xx = int(x)
	for i in range(0, xx + 48):
		print('+')
	print('.')


expr = input()
res = eval(expr)
r1 = res // 100
r2 = res % 100 // 10
r3 = res % 10

def brainfxxk(x: int):
	for i in range(0, 48 + x):
		print('+', end='')
	print('.>', end='')
if r1 != 0:
	brainfxxk(r1)
if r2 != 0:
	brainfxxk(r2)
brainfxxk(r3)


x = input()
x = eval(x)
x = str(x)
ctr = 0
for c in x:
	while ctr < ord(c):
		print('+', end='')
		ctr += 1
	while ctr > ord(c):
		print('-', end='')
		ctr -= 1
	print('.', end='')


a = str(eval(input()))
print('+' * 48)
for i in a:
	i = int(i)
	print('+' * i)
	print('.')
	print('-' * i)


res = eval(input())
lne = str(res)
for i in lne:
	st = '++++++++++++++++++++++++++++++++++++++++++++++++'
	for i in range(ord(i) - ord('0')):
		st += '+'
	st += '.'
	st += '[-]'
	print(st)


str = input()
x = eval(str) % 256
ans = ''
for i in range(0, x):
	ans = ans + '+'
ans = ans + '>'
ans = ans + '>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-'
ans = ans + '<+>] > +>> ] << << < ] > [-] >> [> ++++++[-<++++++++>]<. << +>+> [-]] < [<[-> - < ]++++++[->++++++++'
ans = ans + '< ]>.[-]] << ++++++[-<++++++++>] < .[-] << [-<+>]'
print(ans)


num = str(eval(input()))
s = ''
caret = 0
for i in num:
	if s:
		s += '>'
	s += '+' * ord(i)
	s += '.'
print(s)


import sys
exp = sys.stdin.readline()
result = eval(exp)
cur = 0
for c in bytes(str(result), 'utf8'):
	diff = (c - cur + 256) % 256
	for i in range(0, diff):
		print('+', end='')
	print('.', end='')
	cur = c
print()


inpt = input()
res = eval(inpt)
ress = str(res)
answ = '++++++++++++++++++++++++++++++++++++++++++++++++'
res = 0
for i in range(len(ress)):
	ct = int(ress[i])
	if ct == res:
		answ += '.'
		continue
	if ct > res:
		for j in range(ct - res):
			answ += '+'
	else:
		for j in range(res - ct):
			answ += '-'
	res = ct
	answ += '.'
print(answ)


import collections as col
import itertools as its
import sys
import operator
from bisect import bisect_left, bisect_right
from copy import copy, deepcopy

class Solver:

	def __init__(self):
		pass

	def solve(self):
		expr = input()
		v = eval(expr)
		res = str(v)
		for c in res:
			print('>', end='')
			print('+' * ord(c) + '.', end='')
		print('')
s = Solver()
s.solve()


s = str(eval(input()))
ans = ''
for i in range(len(s)):
	ans += '>'
	for j in range(int(s[i])):
		ans += '+'
	ans += '++++++++++++++++++++++++++++++++++++++++++++++++.'
print(ans)


exp = input()
ans = str(eval(exp))
print(ans)
for digit in ans:
	print('+' * ord(ascii(int(digit))) + '.>', end='\n')


import sys
n = int(eval(sys.stdin.readline()))
s = ''
if n == 0:
	print('++++++++++++++++++++++++++++++++++++++++++++++++.')
else:
	while n > 0:
		d = n % 10 + 48
		n = n // 10
		s = '.>' + s
		while d > 0:
			s = '+' + s
			d -= 1
print(s)


print(''.join(list(map(lambda x: '+' * ord(x) + '.>', str(eval(input()))))))


result = str(eval(input()))
for d in result:
	print('+' * (48 + int(d)) + '.>')


x = eval(input())

def gen_bf(x):
	expr = ''
	for i in range(x + 48):
		expr += '+'
	expr += '.[-]'
	return expr
bf = ''
if x >= 100:
	bf += gen_bf(x // 100)
	bf += gen_bf(x // 10 % 10)
	bf += gen_bf(x % 10)
elif x >= 10:
	bf += gen_bf(x // 10)
	bf += gen_bf(x % 10)
else:
	bf += gen_bf(x)
print(bf)


s = str(eval(input()))
for i in s:
	print('+' * ord(i) + '.>')


n = str(eval(input()))
s = ''
for i in n:
	x = ord(i)
	while x:
		x -= 1
		s += '+'
	s += '.>'
print(s)


a = eval(input())
if a == 0:
	print('++++++++++++++++++++++++++++++++++++++++++++++++.')
else:
	b = []
	while a > 0:
		b.append(a % 10)
		a = a // 10
	b.reverse()
	for x in b:
		print('++++++++++++++++++++++++++++++++++++++++++++++++' + x * '+' + '.>')


target = str(eval(input()))
last = 0
ans = ''
for ch in target:
	curr = ord(ch)
	if curr < last:
		ans += '-' * (last - curr)
	if curr > last:
		ans += '+' * (curr - last)
	ans += '.'
	last = curr
print(ans)


import re
x = re.findall('(\\d+|[+-])', input())
num = int(x[0])
nextop = True
for i in range(1, len(x)):
	if x[i] == '+':
		nextop = True
	elif x[i] == '-':
		nextop = False
	elif nextop:
		num += int(x[i])
	else:
		num -= int(x[i])
s = str(num)
for d in s:
	print(ord(d) * '+' + '.>')


n = str(eval(input()))
for j in n:
	for _ in range(ord(j)):
		print('+')
	print('.')
	for _ in range(ord(j)):
		print('-')


p = input()
q = []
p = p.split('+')
s = 0
for i in p:
	e = [int(x) for x in i.split('-')]
	s += e[0] * 2
	for j in e:
		s -= j
curr = 0
g = []
if s == 0:
	g.append(0)
while s != 0:
	g.append(s % 10)
	s //= 10
g = g[::-1]
for s in g:
	k = s + ord('0')
	while curr < k:
		print('+', end='')
		curr += 1
	while curr > k:
		print('-', end='')
		curr -= 1
	print('.')
	s //= 10


expr = input()
result = eval(expr)
r1 = result // 100
r2 = result % 100 // 10
r3 = result % 10

def bf(x: int):
	for i in range(0, 48 + x):
		print('+', end='')
	print('.>', end='')
if r1 != 0:
	bf(r1)
if r2 != 0:
	bf(r2)
bf(r3)


res = eval(input())
ans = []
s = '>[<+>-]<++++++++++++++++++++++++++++++++++++++++++++++++.>>>'
while res > 0:
	x = res % 10
	s2 = s
	for i in range(x):
		s2 = '+' + s2
	ans.append(s2)
	res //= 10
ans = ans[::-1]
if len(ans) == 0:
	ans.append(s)
for i in range(len(ans)):
	print(ans[i])


a = str(eval(input()))
for x in a:
	print('+' * (48 + int(x)) + '.')
	print('>')


def process(x):
	return '++++++++++++++++++++++++++++++++++++++++++++++++' + ''.join(['+' for i in range(0, x)]) + '.>'

def main():
	res = str(eval(input()))
	for i in res:
		print(process(int(i)))
main()


print(''.join(['+' * ord(x) + '.>' for x in str(eval(input()))]))


ans = str(eval(input()))
for i in range(len(ans)):
	print('+' * ord(ans[i]), end='.>')
print('')


res = str(eval(input()))
for i in res:
	print('+' * ord(i), '.>')


import re

def printNum(n):
	for i in range(n):
		print('+', end='')
string = input()
strings = re.split('([+-])', string)
terms = [int(strings[0])]
i = 1
while i < len(strings):
	if strings[i] == '+':
		terms.append(int(strings[i + 1]))
	i += 2
i = 1
while i < len(strings):
	if strings[i] == '-':
		terms.append(-int(strings[i + 1]))
	i += 2
printNum(terms[0])
i = 1
while i < len(terms):
	print('>')
	if terms[i] > 0:
		printNum(terms[i])
		print('>')
		print('<[<+>-]<')
	elif terms[i] < 0:
		printNum(-terms[i])
		print('>')
		print('<[<->-]<')
	i += 1
print('[>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<[.[-]<]<')


def nd(x):
	return ord('0') + x

def pd(x):
	s = ''
	for i in range(nd(x)):
		s += '+'
	s += '.>'
	print(s)

def pn(x):
	if x >= 100:
		pd(x // 100)
	if x >= 10:
		pd(x // 10 % 10)
	if x >= 1:
		pd(x % 10)
x = eval(input())
if x == 0:
	pd(0)
else:
	pn(x)


x = eval(input())
if x >= 100:
	for i in range(x // 100 + 48):
		print('+')
	print('.>')
if x >= 10:
	for i in range(x // 10 % 10 + 48):
		print('+')
	print('.>')
for i in range(x % 10 + 48):
	print('+')
print('.>')


i = input().strip()
ans = eval(i)
print('>\n>\n<[<+>-]<')
for s in str(ans):
	print('>{}++++++++++++++++++++++++++++++++++++++++++++++++.'.format('+' * int(s)))


def main():
	n = str(eval(input()))
	print('+' * 48)
	for c in n:
		r = ord(c) - 48
		print('+' * r + '.' + '-' * r)

def read(callback=int):
	return list(map(callback, input().strip().split()))

def write(value, end='\n'):
	if value is None:
		return
	try:
		if not isinstance(value, str):
			value = ' '.join(map(str, value))
	except:
		pass
	print(value, end=end)
write(main())


s = str(eval(input()))
for i in range(len(s)):
	t = '>'
	for j in range(ord(s[i])):
		t = t + '+'
	print(t + '.')


f = str(input())
v = eval(f)
prog = ''
for i in range(v):
	prog += '+'
prog += '>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-'
prog += '<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++'
prog += '<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<'
print(prog)


def pr(x):
	for i in range(x + 48):
		print('+', end='')
	print('.', end='')
	for i in range(x + 48):
		print('-', end='')

def work(x):
	if x == 0:
		return
	work(x // 10)
	pr(x % 10)
s = input()
p = eval(s)
if p == 0:
	pr(0)
else:
	work(p)


a = input()
b = eval(a)
print('>')
print('+' * b + '>')
print('<[<+>-]<')
print('[>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]')
print('++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<[.[-]<]<')


exp = input()
ans = str(eval(exp))
for c in ans:
	print('+' * (48 + int(c)) + '.>')


s = input()
x = eval(s)
print('+' * x)
print('>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]')


import sys

def main():
	t = 0
	sign = True
	prev = -1
	s = input().strip() + '.'
	for (i, c) in enumerate(s):
		if not c.isdigit():
			num = int(s[prev + 1:i])
			if sign:
				t += num
			else:
				t -= num
			sign = c == '+'
			prev = i
	u = str(t)
	for c in u:
		d = 48 + ord(c) - ord('0')
		print('+' * d + '.>')
	return 0
sys.exit(main())


print(*['[-]' + '+' * ord(c) + '.' for c in str(eval(input()))], sep='')


expr = input()
val = eval(expr)
prog = ''
vald = []
if val == 0:
	vald.append(0)
else:
	while val:
		vald.append(val % 10)
		val = val // 10
	for i in range(len(vald) // 2):
		(vald[i], vald[len(vald) - 1 - i]) = (vald[len(vald) - 1 - i], vald[i])
for x in vald:
	prog += '[-]'
	for i in range(x + ord('0')):
		prog += '+'
	prog += '.'
print(prog)


n = str(eval(input()))
for i in range(0, 10):
	for x in range(0, 48 + i):
		print('+', end='')
	print('>', end='')
print('<<<<<<<<<<', end='')
p = 0
for x in range(0, len(n)):
	while p != int(n[x]):
		if p < int(n[x]):
			p += 1
			print('>', end='')
		else:
			p -= 1
			print('<', end='')
	print('.', end='')


s = input()
ans = eval(s)
lst = list()
if ans == 0:
	lst.append(0)
while ans:
	lst.append(ans % 10)
	ans //= 10
lst.reverse()
idx = 0
for i in lst:
	num = i + 48
	while idx < num:
		print('+', end='')
		idx += 1
	while idx > num:
		print('-', end='')
		idx -= 1
	print('.')


s = input()
res = str(eval(s))
for c in res:
	print('+' * ord(c) + '.>', end='')
print()


s = eval(input())
if s < 0:
	s += 256
elif s > 255:
	s -= 256
a = []
if s == 0:
	a.append(0)
while s > 0:
	a.append(s % 10)
	s //= 10
a.reverse()
for x in a:
	for unused in range(x + ord('0')):
		print('+', end='')
	print('>')
for x in a:
	print('<')
for x in a:
	print('.>')


ans = str(eval(input()))
for i in ans:
	print('+' * (int(i) + 48) + str('.>'))


from cmath import log10
s = input()
a = eval(s)
if a < 0:
	print('+++++++++++++++++++++++++++++++++++++++++++++.>')
	a *= -1
q = a + (a % 10 == 0) + (a == 0)
l = str(log10(q)).split('.')
l = l[0]
l = int(l[1:]) + 1
for i in range(l):
	q = a // 10 ** (l - i - 1)
	a = a % 10 ** (l - i - 1)
	b = '++++++++++++++++++++++++++++++++++++++++++++++++'
	b += '+' * q
	b += '.>'
	print(b)


exp = input()
value = str(eval(exp))
for i in range(len(value)):
	for s in range(ord(value[i])):
		print('+', end='')
	print('.>', end='')


s = input()
x = 0
y = 0
op = None
for v in s:
	if v == '+' or v == '-':
		if op == '+':
			y += x
		elif op == '-':
			y -= x
		else:
			y = x
		op = v
		x = 0
	else:
		x = x * 10 + int(v)
if op == '+':
	y += x
elif op == '-':
	y -= x
else:
	y = x
res = []
while y:
	res.append(y % 10)
	y //= 10
print('+' * 48)
if res:
	old = 0
	for next in reversed(res):
		print('+' * (next - old) + '-' * (old - next) + '.')
		old = next
else:
	print('.')


inp = input()
num = str(eval(inp))
for i in num:
	print('>' + '+' * ord(i) + '.')


v = str(eval(input()))
for c in v:
	print('+' * ord(c) + '.>')


x = input()
x = str(eval(x))
for i in x:
	for j in range(0, ord(i)):
		print('+')
	print('.')
	for j in range(0, ord(i)):
		print('-')


val = eval(input())
zero = ' ++++++++++++++++++++++++++++++++++++++++++++++++'
l = [int(x) for x in list(str(val))]
l = [zero + '+' * x + '.' + '>' for x in l]
print('\n'.join(l))


s = input()
r = eval(s)
r1 = r // 100
r2 = r % 100 // 10
r3 = r % 10

def get(x: int):
	for i in range(0, 48 + x):
		print('+', end='')
	print('.>', end='')
if r1 != 0:
	get(r1)
if r2 != 0:
	get(r2)
get(r3)


s = input()
s = str(eval(s))

def pr(x):
	for i in range(int(x) + 48):
		print('+', end='')
	print('.>')
for i in range(len(s)):
	pr(s[i])


a = eval(input())
(b, p) = ([a // 100, a % 100 // 10, a % 10], 0)
for i in range(3):
	if i == 2 or p == 1 or b[i] > 0:
		p = 1
		print('+' * (b[i] + 48) + '.')
		print('-' * (b[i] + 48))


e = input()
numbers = e
numbers = numbers.replace('-', '+')
numbers = numbers.split('+')
ans = int(numbers[0])
pos = len(numbers[0])
for i in range(1, len(numbers)):
	if e[pos] == '+':
		ans += int(numbers[i])
	else:
		ans -= int(numbers[i])
	pos += 1 + len(numbers[i])
print('+' * ans, end='')
print('[>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]\n\t\t  ++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<[.[-]<]<')


n = str(eval(input()))
for x in n:
	print('>')
	for i in range(ord(x)):
		print('+', end='')
	print('.')


ans = str(eval(input()))
for i in ans:
	s = ''
	for k in range(ord(i)):
		s += '+'
	s += '.>'
	print(s)


inp = input()
res = eval(inp)
if res >= 100:
	for i in range(res // 100):
		print('+', end='')
	print('++++++++++++++++++++++++++++++++++++++++++++++++.>')
if res >= 10:
	for i in range(res % 100 // 10):
		print('+', end='')
	print('++++++++++++++++++++++++++++++++++++++++++++++++.>')
for i in range(res % 10):
	print('+', end='')
print('++++++++++++++++++++++++++++++++++++++++++++++++.')


s = input()
s = s.replace('+', ' + ')
s = s.replace('-', ' - ')
s = s.split()
summ = int(s[0])
for i in range(2, len(s), 2):
	if s[i - 1] == '+':
		summ += int(s[i])
	else:
		summ -= int(s[i])
s = str(summ)
for each in s:
	print('+' * ord(each) + '.' + '>')


s = input()
s = 'a = ' + s
exec(s)
a = str(a)
for i in range(0, 48):
	print('+', end='')
for c in a:
	for i in range(0, int(c)):
		print('+', end='')
	print('.')
	for i in range(0, int(c)):
		print('-', end='')


a = input().strip()
b = []
for i in range(len(a)):
	if a[i] == '+' or a[i] == '-':
		b += [a[i]]
b += ['+']
a = '+'.join(a.split('-'))
q = list(map(int, a.split('+')))
r = 0
c = '+'
for i in range(len(q)):
	if c == '+':
		r += q[i]
	if c == '-':
		r -= q[i]
	c = b[i]
r = str(r)
v = 0
s = ''
for x in r:
	n = ord(x)
	while v != n:
		v = (v + 1) % 256
		s += '+'
	s += '.'
print(s)


n = eval(input())
for ch in str(n):
	x = ord(ch)
	print('+' * x, end='.>\n')


a = str(eval(input()))
print('+' * ord(a[0]), end='')
print('.', end='')
for i in range(1, len(a)):
	print('>', '+' * ord(a[i]), '.', end='')


n = str(eval(input()))
for _ in n:
	print('.'.join(['+' * ord(_), '-' * ord(_)]))


def print_dig(x):
	x += ord('0')
	print('+' * x)
	print('.')
	print('-' * x)

def main():
	n = eval(input())
	if n >= 100:
		print_dig(n // 100)
	if n >= 10:
		print_dig(n // 10 % 10)
	print_dig(n % 10)
main()


s = str(eval(input()))

def printf(c):
	print('+' * ord(c) + '.>')
for i in s:
	printf(i)


e = str(eval(input()))
for c in e:
	print('+' * (int(c) + ord('0')) + '.>')


for d in str(eval(input())):
	print(ord('0') * '+' + int(d) * '+' + '.>')


N = input()
T = eval(N)
N1 = T // 100
N2 = T % 100 // 10
N3 = T % 10

def Output(X: int):
	for i in range(0, 48 + X):
		print('+', end='')
	print('.>', end='')
if N1 != 0:
	Output(N1)
if N2 != 0:
	Output(N2)
Output(N3)


res = eval(input())
s = ''
if res >= 100:
	s += '+' * (res // 100 + 48) + '.>'
if res >= 10:
	s += '+' * (res // 10 % 10 + 48) + '.>'
s += '+' * (res % 10 + 48) + '.'
print(s)


def main():
	import re
	try:
		while True:
			x = eval(input())
			print('+' * 48)
			if x == 0:
				print('.')
			else:
				if x >= 100:
					(y, x) = divmod(x, 100)
					print('+' * y, '.', '-' * y)
				if x >= 10:
					(y, x) = divmod(x, 10)
					print('+' * y, '.', '-' * y)
				print('+' * x, '.')
	except EOFError:
		pass
main()


digits = '0123456789'
a = input() + ' '

def get_dig(i):
	x = 0
	while (i < len(a)) & (a[i] in digits):
		x = 10 * x + int(a[i])
		i += 1
	return (i, x)
(i, x) = get_dig(0)
while i + 1 < len(a):
	if a[i] == '+':
		(i, y) = get_dig(i + 1)
		x += y
	else:
		(i, y) = get_dig(i + 1)
		x -= y
s = str(x)
out = ''
for letter in s:
	for i in range(ord(letter)):
		out += '+'
	out += '.>'
print(out)


a = str(eval(input()) % 256)
out = ''
for c in a:
	out += '>' + '+' * (int(c) + 48) + '.'
print(out)


ans = str(eval(input()))
print('++++++++++++++++++++++++++++++++++++++++++++++++')
v = 0
for c in ans:
	d = int(c) - v
	print(('+' if d >= 0 else '-') * abs(d) + '.')
	v += d


s = input()
res = eval(s)
d = s.replace('+', ' ').replace('-', ' ')
n = [*map(int, d.split())]
ops = []
for i in s:
	if not i.isdigit():
		ops += [i]
data = []
for i in n:
	print('+' * i + '>')
print('<' * (len(n) - 1), end='')
for i in range(len(n) - 1):
	print('[', '<' * (i + 1), ops[i], '>' * (i + 1), '-', ']', end='', sep='')
	if i == len(n) - 2:
		print('<' * (len(n) - 2))
	else:
		print('>', end='')
res = str(res)
prev = 0
for i in res:
	curr = 48 + int(i)
	if curr == prev:
		print('.', end='', sep='')
	elif curr > prev:
		print('+' * (curr - prev), '.', end='', sep='')
	else:
		print('-' * (prev - curr), '.', end='', sep='')
	prev = curr


exec('res = ' + input())
print('+' * 48)
for c in str(res):
	print('+' * int(c) + '.')
	print('-' * int(c))


print('\n'.join(['++++++++++++++++++++++++++++++++++++++++++++++++' + '+' * (ord(i) - ord('0')) + '.[-]' for i in str(eval(input()))]))


n = str(eval(input()))
for i in n:
	for _ in range(ord(i)):
		print('+')
	print('.')
	for _ in range(ord(i)):
		print('-')


l = list()
a = eval(input())
while True:
	b = a % 10
	a //= 10
	l.append('+' * (48 + b) + '.>')
	if a == 0:
		break
for i in reversed(l):
	print(i)


x = eval(input())
y = x
while y >= 10:
	y //= 10
if y < 8:
	cur = 3
	print('-[----->+<]>', end='')
else:
	cur = 9
	print('+[--------->+<]>', end='')
if x >= 100:
	tmp = x // 100
	s = '.'
	if tmp > cur:
		s = '+' * (tmp - cur) + s
	if tmp < cur:
		s = '-' * (cur - tmp) + s
	cur = tmp
	print(s, end='')
x %= 100
if x >= 10:
	tmp = x // 10
	s = '.'
	if tmp > cur:
		s = '+' * (tmp - cur) + s
	if tmp < cur:
		s = '-' * (cur - tmp) + s
	cur = tmp
	print(s, end='')
x %= 10
tmp = x
s = '.'
if tmp > cur:
	s = '+' * (tmp - cur) + s
if tmp < cur:
	s = '-' * (cur - tmp) + s
cur = tmp
print(s, end='')