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.

Difficulty: HARD

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


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


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


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


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


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('.>')


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()


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) + '.>')


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


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


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) * '+' + '.>')


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()


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)


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


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())


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


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


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])


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


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) + '.' + '>')


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


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) * '+' + '.>')


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)