Problem: You are given string s consists of opening and closing brackets of four kinds <>, {}, [], (). There are two types of brackets: opening and closing. You can replace any bracket by another of the same type. For example, you can replace < by the bracket {, but you can't replace it by ) or >.

The following definition of a regular bracket sequence is well-known, so you can be familiar with it.

Let's define a regular bracket sequence (RBS). Empty string is RBS. Let s1 and s2 be a RBS then the strings <s1>s2, {s1}s2, [s1]s2, (s1)s2 are also RBS.

For example the string "[[(){}]<>]" is RBS, but the strings "[)()" and "][()()" are not.

Determine the least number of replaces to make the string s RBS.

Input

The only line contains a non empty string s, consisting of only opening and closing brackets of four kinds. The length of s does not exceed 106.

Output

If it's impossible to get RBS from s print Impossible.

Otherwise print the least number of replaces needed to get RBS from s.

Examples

Input

[&lt;}){}


Output

2

Input

{()}[]


Output

0

Input

]]


Output

Impossible

Solution (in JAVA):

Solution:
	import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.LinkedList;
		
			 
			public class Solution1 implements Runnable
			{
				static final int MAX = 1000000007;
				static class InputReader
				{
					private InputStream stream;
					private byte[] buf = new byte[1024];
					private int curChar;
					private int numChars;
					private SpaceCharFilter filter;
					private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			
					public InputReader(InputStream stream)
					{
						this.stream = stream;
					}
					
					public int read()
					{
						if (numChars==-1) 
							throw new InputMismatchException();
						
						if (curChar >= numChars)
						{
							curChar = 0;
							try 
							{
								numChars = stream.read(buf);
							}
							catch (IOException e)
							{
								throw new InputMismatchException();
							}
							
							if(numChars <= 0)				
								return -1;
						}
						return buf[curChar++];
					}
				 
					public String nextLine()
					{
						String str = "";
			            try
			            {
			                str = br.readLine();
			            }
			            catch (IOException e)
			            {
			                e.printStackTrace();
			            }
			            return str;
					}
					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 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 double nextDouble() 
					{
						int c = read();
						while (isSpaceChar(c))
							c = read();
						int sgn = 1;
						if (c == '-') 
						{
							sgn = -1;
							c = read();
						}
						double res = 0;
						while (!isSpaceChar(c) && c != '.') 
						{
							if (c == 'e' || c == 'E')
								return res * Math.pow(10, nextInt());
							if (c < '0' || c > '9')
								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
							c = read();
						}
						if (c == '.') 
						{
							c = read();
							double m = 1;
							while (!isSpaceChar(c)) 
							{
								if (c == 'e' || c == 'E')
									return res * Math.pow(10, nextInt());
								if (c < '0' || c > '9')
									throw new InputMismatchException();
								m /= 10;
								res += (c - '0') * m;
								c = read();
							}
						}
						return res * sgn;
					}
					
					public String readString() 
					{
						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 boolean isSpaceChar(int c) 
					{
						if (filter != null)
							return filter.isSpaceChar(c);
						return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
					}
				 
					public String next() 
					{
						return readString();
					}
					
					public interface SpaceCharFilter 
					{
						public boolean isSpaceChar(int ch);
					}
				}
			 	
				public static void main(String args[]) throws Exception
				{
					new Thread(null, new Solution1(),"Solution1",1<<26).start();
				}	
				public void run()
				{
					InputReader sc= new InputReader(System.in);
					PrintWriter w= new PrintWriter(System.out);
					String s = sc.next();
					LinkedList<Character> l=  new LinkedList();
					int count = 0;
					HashMap<Character,Character> hmap = new HashMap();
					hmap.put(')','(');
					hmap.put(']','[');
					hmap.put('}','{');
					hmap.put('>','<');
					for(int i = 0;i < s.length();i++){
						if(s.charAt(i) == ')' || s.charAt(i) == '}' || s.charAt(i) == ']' || s.charAt(i) == '>'){
							if(l.isEmpty()){
								w.println("Impossible");
								w.close();
								System.exit(0);
							}else{
								if(l.peekLast() != hmap.get(s.charAt(i))){
									l.pollLast();
									count++;
								}else{
									l.pollLast();
								}
							}
						}else{
							l.addLast(s.charAt(i));
						}
					}
					if(l.isEmpty()){
						w.println(count);
					}else{
						w.println("Impossible");
					}
					w.close();
				}
				
				static class Pair implements Comparable<Pair>{
					long a;
					int b;
					Pair(long a,int b){
						this.a = a;
						this.b = b;
					}
					public boolean equals(Object o)
					{
						Pair p = (Pair)o;
						return p.a==a && p.b==b;
					}
					public int compareTo(Pair p){
						return Long.compare(this.a,p.a);
					}
					public int hashCode()
					{
						return new Long(a).hashCode()*31 + new Long(a).hashCode();
					}
				}
			}