Vasya is a regular participant at programming contests and is already experienced in finding important sentences in long statements. Of course, numbers constraints are important — factorization of a number less than 1000000 is easier than of a number less than 1000000000. However, sometimes it's hard to understand the number at the first glance. Could it be shortened? For example, instead of 1000000 you could write 10^{6}, instead of 1000000000 —10^{9}, instead of 1000000007 — 10^{9}+7.

Vasya decided that, to be concise, the notation should follow several rules: 

  * the notation should only consist of numbers, operations of addition ("+"), multiplication ("*") and exponentiation ("^"), in particular, the use of braces is forbidden; 
  * the use of several exponentiation operations in a row is forbidden, for example, writing "2^3^4" is unacceptable; 
  * the value of the resulting expression equals to the initial number; 
  * the notation should consist of the minimal amount of symbols. 



Given n, find the equivalent concise notation for it.

Input

The only line contains a single integer n (1 ≤ n ≤ 10 000 000 000).

Output

Output a concise notation of the number n. If there are several concise notations, output any of them.

Examples

Input

2018


Output

2018


Input

1000000007


Output

10^9+7


Input

10000000000


Output

100^5


Input

2000000000


Output

2*10^9

Note

The third sample allows the answer 10^10 also of the length 5.

Difficulty: VERY_HARD
Tags: Mathematics

Complete search

Implementation

Greedy algorithms
Skill types: Complete search

Greedy algorithms

Starter code:

Solutions:
import math
import itertools
pow10 = [1]
for i in range(10):
	pow10.append(pow10[-1] * 10)

def getlen(x):
	return int(math.log10(x)) + 1

class ShortestRepresentation:

	def __init__(self, n):
		self.n = n
		self._m = {}
		self._s = [set() for i in range(10)]
		self._generate_powers()
		self._generate_power_and_power(7)
		self._generate_simple_and_power(7)

	def _generate_powers(self):
		range_x = itertools.takewhile(lambda x: x ** 2 <= self.n, itertools.count(2))
		for x in range_x:
			c = x ** 2
			p = 2
			while c <= self.n:
				self.update(c, '{}^{}'.format(x, p))
				c *= x
				p += 1

	def _generate_power_and_power(self, maxlen):
		for i in range(1, maxlen + 1):
			range_j = itertools.takewhile(lambda j: i + j + 1 <= maxlen, itertools.count(i))
			for j in range_j:
				for (x, y) in itertools.product(self._s[i], self._s[j]):
					x2 = self.get(x)
					y2 = self.get(y)
					self.update(x * y, '{}*{}'.format(x2, y2))

	def _generate_simple_and_power(self, maxlen):
		for i in range(1, maxlen - 1):
			range_xy = itertools.product(range(1, pow10[maxlen - 1 - i]), self._s[i])
			for (x, y) in range_xy:
				y2 = self.get(y)
				self.update(x * y, '{}*{}'.format(x, y2))

	def update(self, x, s):
		if x > self.n:
			return
		ls = len(s)
		if ls >= getlen(x):
			return
		if x not in self._m:
			self._m[x] = s
			self._s[ls].add(x)
		else:
			lm = len(self._m[x])
			if ls < lm:
				self._s[lm].remove(x)
				self._m[x] = s
				self._s[ls].add(x)

	def get(self, x):
		return self._m[x] if x in self._m else str(x)
n = int(input())
if n < 10 ** 10:
	sr = ShortestRepresentation(n)
	ans = sr.get(n)
	range_i = itertools.takewhile(lambda i: i * 2 + 1 < len(ans), itertools.count())
	for i in range_i:
		range_x = itertools.chain(range(1, pow10[i] + 1), sr._s[i])
		for x in range_x:
			ans = min(ans, '{}+{}'.format(sr.get(x), sr.get(n - x)), key=len)
			if n % x > 0:
				continue
			ans = min(ans, '{}*{}'.format(sr.get(x), sr.get(n // x)), key=len)
	print(ans)
else:
	print('100^5')