Problem: Implication is a function of two logical arguments, its value is false if and only if the value of the first argument is true and the value of the second argument is false. 

Implication is written by using character '<image>', and the arguments and the result of the implication are written as '0' (false) and '1' (true). According to the definition of the implication: 

<image>

<image>

<image>

<image>

When a logical expression contains multiple implications, then when there are no brackets, it will be calculated from left to fight. For example,

<image>. 

When there are brackets, we first calculate the expression in brackets. For example,

<image>.

For the given logical expression <image> determine if it is possible to place there brackets so that the value of a logical expression is false. If it is possible, your task is to find such an arrangement of brackets.

Input

The first line contains integer n (1 ≤ n ≤ 100 000) — the number of arguments in a logical expression.

The second line contains n numbers a1, a2, ..., an (<image>), which means the values of arguments in the expression in the order they occur.

Output

Print "NO" (without the quotes), if it is impossible to place brackets in the expression so that its value was equal to 0.

Otherwise, print "YES" in the first line and the logical expression with the required arrangement of brackets in the second line.

The expression should only contain characters '0', '1', '-' (character with ASCII code 45), '>' (character with ASCII code 62), '(' and ')'. Characters '-' and '>' can occur in an expression only paired like that: ("->") and represent implication. The total number of logical arguments (i.e. digits '0' and '1') in the expression must be equal to n. The order in which the digits follow in the expression from left to right must coincide with a1, a2, ..., an.

The expression should be correct. More formally, a correct expression is determined as follows:

  * Expressions "0", "1" (without the quotes) are correct. 
  * If v1, v2 are correct, then v1->v2 is a correct expression. 
  * If v is a correct expression, then (v) is a correct expression. 



The total number of characters in the resulting expression mustn't exceed 106.

If there are multiple possible answers, you are allowed to print any of them.

Examples

Input

4
0 1 1 0


Output

YES
(((0)-&gt;1)-&gt;(1-&gt;0))


Input

2
1 1


Output

NO


Input

1
0


Output

YES
0

Solution (in JAVA):

Solution:
import java.io.IOException;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.LinkedList;

public class BracketsInImplications {
    public static void main(String[] args) {
        FasterScanner sc = new FasterScanner();
        
        int N = sc.nextInt();
        int[] A = sc.nextIntArray(N);
        
        if (N == 1) {
        	System.out.println((A[0] == 0) ? "YES\n0" : "NO");
        	return;
        }
        
        if (A[N - 1] == 1) {
        	System.out.println("NO");
        	return;
        }

        ArrayList<Integer> sp = new ArrayList<Integer>();
        ArrayList<Integer> ep = new ArrayList<Integer>();
        
        if (A[N - 2] == 1) {
        	sp.add(0);
        	ep.add(N - 3);
        	System.out.println("YES");
        	System.out.println(makeStr(A, sp, ep));
        } else {
        	int zeroIdx = -1;
        	for (int i = N - 3; i >= 0; i--) {
        		if (A[i] == 0) {
        			zeroIdx = i;
        			break;
        		}
        	}
        	if (zeroIdx < 0) {
        		System.out.println("NO");
        	} else {
        		sp.add(zeroIdx + 1);
        		ep.add(N - 2);
        		sp.add(zeroIdx);
        		ep.add(N - 2);
        		sp.add(0);
        		ep.add(zeroIdx - 1);
        		System.out.println("YES");
            	System.out.println(makeStr(A, sp, ep));
        	}
        }
        
//        int[][] impl = new int[2][2];
//        impl[0][0] = 1;
//        impl[0][1] = 1;
//        impl[1][0] = 0;
//        impl[1][1] = 1;
//        int doneIdx = -1;
//        int seek = 1;
//        int trgt = 0;
//        int zeroFwdIdx = -1;
//        int prev = A[N - 1];
//        for (int i = N - 2; i >= 0; i--) {
//        	if (A[i] == 0 && prev == 0 && trgt == 0) {
//        		trgt = 1;
//        	} else if (A[i] == 0 && prev == 0 && trgt == 1) {
//        		sp.add(i);
//        		ep.add(i + 1);
//        		sp.add(0);
//        		ep.add(i - 1);
//        		break;
//        	} else if (A[i] == 0 && prev == 1 && trgt == 0) {
//        		
//        	} else if (A[i] == 0 && prev == 1 && trgt == 1) {
//        		
//        	} else if (A[i] == 1 && prev == 0 && trgt == 0) {
//        		sp.add(0);
//        		ep.add(i - 1);
//        		break;
//        	} else if (A[i] == 1 && prev == 0 && trgt == 1) {
//        		if (zeroFwdIdx < 0) {
//        			zeroFwdIdx = i + 1;
//        		}
//        		sp.add(i);
//        		sp.add(zeroFwdIdx);
//        		trgt = 0;
//        	} else if (A[i] == 1 && prev == 1 && trgt == 0) {
//        		
//        	} else if (A[i] == 1 && prev == 1 && trgt == 1) {
//        		
//        	}
//        	
////        	if (prev == 0 && A[i] == 0) {
////        		if (trgt == 0) {
////        			
////        		} else {
////        			doneIdx = i;
////        			break;
////        		}
////        	} else if (prev == 0 && A[i] == 1) {
////        		if (trgt == 0) {
////        			
////        		} else {
////	        		doneIdx = i;
////	        		break;
////        		}
////        	} else if (prev == 1 && A[i] == 0) {
////        		if (trgt == 0) {
////        			doneIdx = i;
////        			break;
////        		} else {
////        			
////        		}
////        	} else if (prev == 1 && A[i] == 1) {
////        		if (trgt == 0) {
////        			
////        		} else {
////        			doneIdx = i;
////        			break;
////        		}
////        	}
//        	
////        	if (A[i] == seek) {
////        		doneIdx = i;
////        		break;
////        	}
////        	if (A[i] == 0) {
////        		seek = 0;
////        	}
//        }
//        
//        if (doneIdx < 0) {
//        	System.out.println("NO");
//        	return;
//        }
//        
//        System.out.println(doneIdx);
//        
//        StringBuilder sb = new StringBuilder();
//        sb.append("(");
//        sb.append(A[0]);
//        for (int i = 1; i < doneIdx; i++) {
//        	sb.append("->" + A[i]);
//        }
//        sb.append(")");
//        for (int i = doneIdx; i < N; i++){ 
//        	sb.append("->" + A[i]);
//        }
//        System.out.println(sb.toString());
    }
    
    public static String makeStr(int[] arr, ArrayList<Integer> sp, ArrayList<Integer> ep) {
    	int N = arr.length;
    	CharList[] strs = new CharList[N];
    	for (int i = 0; i < N; i++) {
    		strs[i] = new CharList();
    		strs[i].add((char)(arr[i] + '0'));
    	}
    	
    	for (int i = 0; i < sp.size(); i++) {
    		int s = sp.get(i);
    		int e = ep.get(i);
    		if (s <= e) {
    			strs[s].addFirst('(');
    			strs[e].addLast(')');
    		}
    	}
    	
    	StringBuilder sb = new StringBuilder();
    	sb.append(strs[0].getStr());
    	for (int i = 1; i < N; i++) {
    		sb.append("->" + strs[i].getStr());
    	}
    	return sb.toString();
    }
    
    public static class CharList extends LinkedList<Character> {
		private static final long serialVersionUID = 8645498336274358988L;
		
		public String getStr() {
        	StringBuilder sb = new StringBuilder();
        	for (char c : this) {
        		sb.append(c);
        	}
        	return sb.toString();
		}
    }
    
	public static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = System.in.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
	        
	    public int[] nextIntArray(int n) {
	        return nextIntArray(n, 0);
	    }
	    
	    public int[] nextIntArray(int n, int off) {
	    	int[] arr = new int[n + off];
	    	for (int i = 0; i < n; i++) {
	    		arr[i + off] = nextInt();
	    	}
	    	return arr;
	    }
	    
	    public long[] nextLongArray(int n) {
	    	return nextLongArray(n, 0);
	    }
        
		public long[] nextLongArray(int n, int off) {
		    long[] arr = new long[n + off];
		    for (int i = 0; i < n; i++) {
		        arr[i + off] = nextLong();
		    }
		    return arr;
		}

	    private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}
}