One day, Ikta, an elementary school student, received a piece of paper with mathematical formulas from his grandfather. Apparently, the grandfather will give you as much money as the answer to the formula. Ikta has only learned addition, subtraction, and multiplication, so only addition, subtraction, and multiplication are used in mathematical formulas. In normal calculation, multiplication must be calculated before addition and subtraction, but Ikta had a vague understanding of operator precedence, so for the time being, it is convenient to maximize the calculation result of the formula. I decided to consider a good priority.

Given the three binary operators + − × and a formula containing parentheses. Change the precedence of the three operators as you like and answer the calculation result when the formula is maximized.

However, note the following points.

* Operators are always left-associative. (Operators with the same precedence are always calculated from the left side of the formula.)
* Different operators may have the same precedence.
* Do not change the priority while calculating one formula.



Input

The input is given in the following format.
A formula consisting of numbers from 0 to 9 and the operators'+','-','*' and parentheses'(',')'


* To be precise, the input is in the format shown in BNF below.



> <expr> :: = (<expr>) | <number> | <expr> <op> <expr>
> <op> :: = + |-| *

<number> represents a non-negative integer.

Constraints

The input satisfies the following constraints.

* The formula is 200 characters or less.
* No matter what priority is set, it will not overflow as a result of calculation or in the middle of it as a 64-bit integer type.

Output

Output the maximum value obtained from the formula in one line.

Examples

Input

3-2*3


Output

3


Input

(5-3*4)*(0-2+1)


Output

21


Input

1-2+3-4+5-6*0


Output

3


Input

(1989967-3*1-211+4487)


Output

8511076028
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

import static java.lang.Integer.parseInt;

/**
 * Unordered Operators
 */
public class Main {

	static Main main;
	static int[][] PRI;
	static final int[][] _PRI = {
			{1, 2, 3},
			{1, 3, 2},
			{2, 1, 3},
			{2, 3, 1},
			{3, 1, 2},
			{3, 2, 1},
			//
			{1, 1, 2},
			{1, 2, 1},
			{2, 1, 1},
			//
			{2, 2, 1},
			{2, 1, 2},
			{1, 2, 2},
			//
			{2, 2, 2},
	};

	//priority list
	{
		PRI = new int[_PRI.length][128];
		for (int i = 0; i < PRI.length; i++) {
			PRI[i]['('] = 5;
			PRI[i][127] = 4;
			PRI[i]['+'] = _PRI[i][0];
			PRI[i]['-'] = _PRI[i][1];
			PRI[i]['*'] = _PRI[i][2];
			PRI[i][')'] = 0;
			PRI[i]['\0'] = -1;
		}
	}

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line;
		String[] words;

		main = new Main();

		//parse
		line = br.readLine();
		words = line.split("(?<!\\d)|(?!\\d)");
		List<Elm> expr = new ArrayList<>();

		for (String word : words) {
			char c = word.charAt(0);
			switch (c) {
				case '(':
					expr.add(main.new Lp());
					break;
				case ')':
					expr.add(main.new Rp());
					break;
				case '+':
					expr.add(main.new Add());
					break;
				case '-':
					expr.add(main.new Subtract());
					break;
				case '*':
					expr.add(main.new Multiply());
					break;
				default:
					expr.add(main.new Num(parseInt(word)));
			}
		}

		//solve
		long max = Long.MIN_VALUE;
		for (int i = 0; i < PRI.length; i++) {
			//toString(expr);
			max = Math.max(max, eval(postfix(expr, PRI[i])));
		}
		System.out.println(max);
	}

	static List<Elm> postfix(List<Elm> expr, int[] pri) {
		Deque<Elm> stack = new ArrayDeque<>();
		List<Elm> list = new ArrayList<>();

		stack.push(main.new Nop());
		for (Elm e : expr) {
			int p1, p2;
			p1 = pri[stack.peek().pri()];
			p2 = pri[e.pri()];
			while (p2 <= p1 && !(stack.peek() instanceof Lp)) {
				list.add(stack.pop());
				p1 = pri[stack.peek().pri()];
			}
			if (!(e instanceof Rp)) {
				stack.push(e);
			} else {
				//remove '('
				stack.pop();
			}
		}
		while (!(stack.peek() instanceof Nop)) {
			list.add(stack.pop());
		}
		return list;
	}

	static long eval(List<Elm> expr) {
		Deque<Long> stack = new ArrayDeque<>();

//		toString(expr);

		for (Elm e : expr) {
			if (e instanceof Op) {
				long a, b;
				b = stack.pop();
				a = stack.pop();
				stack.push(((Op) e).operate(a, b));
			} else {
				stack.push(((Num) e).value);
			}
		}
		return stack.pop();
	}

//	static void toString(List<Elm> expr) {
//		for (Elm e : expr) {
//			if (e instanceof Op) {
//				System.out.print((char) e.pri());
//			} else {
//				System.out.print(((Num) e).value);
//			}
//			System.out.print(' ');
//		}
//		System.out.println();
//	}

	//
	interface Elm {
		int pri();
	}

	interface Op extends Elm {
		long operate(long a, long b);
	}

	class Lp implements Op {

		@Override
		public long operate(long a, long b) {
			return 0;
		}

		@Override
		public int pri() {
			return '(';
		}
	}

	class Rp implements Op {

		@Override
		public long operate(long a, long b) {
			return 0;
		}

		@Override
		public int pri() {
			return ')';
		}
	}

	class Add implements Op {

		@Override
		public long operate(long a, long b) {
			return a + b;
		}

		@Override
		public int pri() {
			return '+';
		}
	}

	class Subtract implements Op {

		@Override
		public long operate(long a, long b) {
			return a - b;
		}

		@Override
		public int pri() {
			return '-';
		}
	}

	class Multiply implements Op {

		@Override
		public long operate(long a, long b) {
			return a * b;
		}

		@Override
		public int pri() {
			return '*';
		}
	}

	class Nop implements Op {

		@Override
		public long operate(long a, long b) {
			return 0;
		}

		@Override
		public int pri() {
			return 0;
		}
	}

	class Num implements Elm {
		long value;

		Num(long value) {
			this.value = value;
		}

		@Override
		public int pri() {
			return 127;
		}
	}
}