Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Problem B:
Miscalculation

Bob is an elementary schoolboy, not so good at mathematics. He found Father's calculator and tried cheating on his homework using it. His homework was calculating given expressions containing multiplications and additions. Multiplications should be done prior to additions, of course, but the calculator evaluates the expression from left to right, neglecting the operator precedence. So his answers may be the result of either of the following two calculation rules.

Doing multiplication before addition

Doing calculation from left to right neglecting the operator precedence

Write a program that tells which of the rules is applied from an expression and his answer.

An expression consists of integers and operators. All the integers have only one digit, from 0 to 9. There are two kinds of operators + and *, which represent addition and multiplication, respectively.

The following is an example expression.

1+2*3+4

Calculating this expression with the multiplication-first rule, the answer is 11, as in Sample Input 1. With the left-to-right rule, however, the answer will be 13 as shown in Sample Input 2.

There may be cases in which both rules lead to the same result and you cannot tell which of the rules is applied. Moreover, Bob sometimes commits miscalculations. When neither rules would result in Bob’s answer, it is clear that he actually did.

Input

The input consists of a single test case specified with two lines. The first line contains the expression to be calculated. The number of characters of the expression is always odd and less than or equal to 17. Each of the odd-numbered characters in the expression is a digit from '0' to '9'. Each of the even-numbered characters is an operator '+' or '*'. The second line contains an integer which ranges from 0 to 999999999, inclusive. This integer represents Bob's answer for the expression given in the first line.

Output

Output one of the following four characters:

M     When only the multiplication-first rule results Bob's answer.

L     When only the left-to-right rule results Bob's answer.

U     When both of the rules result Bob's answer.

I     When neither of the rules results Bob's answer.

Sample Input 1

1+2*3+4
11

Sample Output 1

M

Sample Input 2

1+2*3+4
13

Sample Output 2

L

Sample Input 3

3
3

Sample Output 3

U

Sample Input 4

1+2*3+4
9

Sample Output 4

I

Solution in JAVA (judge verdict: Accepted)

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		String expr = s.nextLine();
		long answer = Long.parseLong(s.nextLine());
		long bobs = bobsAnswer(expr);
		long calc = calculate(expr);
		if (bobs == answer) {
			System.out.println(bobs == calc ? "U" : "L");
		} else {
			System.out.println(calc == answer ? "M" : "I");
		}
	}

	private static long calculate(String expr) {
		ArrayList<String> tokens = lex(expr);
		while(tokens.size() > 1) {
			boolean hasAst = false;
			for(int i = 0; i < tokens.size(); i++) {
				if (tokens.get(i).equals("*")) {
					long v = Long.parseLong(tokens.get(i-1)) * Long.parseLong(tokens.get(i+1));
					tokens.set(i, String.valueOf(v));
					tokens.remove(i+1);
					tokens.remove(i-1);
					hasAst = true;
					continue;
				}
			}
			if (hasAst) {
				continue;
			}
			long total = 0L;
			for(String token : tokens) {
				if ("+".equals(token)) {
					continue;
				}
				total += Long.parseLong(token);
			}
			return total;
		}
		return Long.parseLong(tokens.get(0));
	}

	private static ArrayList<String> lex(String expr) {
		ArrayList<String> tokens = new ArrayList<String>();
		String[] nums = expr.split("\\+|\\*");
		String[] symbol = expr.split("[0-9]+");
		for(int i = 1; i < symbol.length; i++) {
			tokens.add(nums[i-1]);
			tokens.add(symbol[i]);
		}
		tokens.add(nums[nums.length-1]);
		return tokens;
	}

	private static long bobsAnswer(String expr) {
		ArrayList<String> tokens = lex(expr);
		if (tokens.size() <= 1) {
			return Long.parseLong(tokens.get(0));
		}
		long total = Long.parseLong(tokens.get(0));
		for(int i = 1; i < tokens.size(); i+=2) {
			long next = Long.parseLong(tokens.get(i+1));
			if ("+".equals(tokens.get(i))) {
				total += next;	
			} else {
				total *= next;
			}
		}
		return total;
	}
	
}