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
import java.util.*;
import java.io.*;

//	close open
//sq	  0    1
//tr    0    1
//cb    1    0
//nb    1    0

public class B{
	public static void main(String[] args)
	{
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		char[] arr = fs.next().toCharArray();
		
		int cur = 0;
		boolean flag = true;
		
		for(char ch:arr)
		{
			if(ch == '(' || ch == '<' || ch == '[' || ch == '{')cur++;
			else
			{
				cur--;
				if(cur<0)
				{
					flag = false;
					break;
				}
			}
		}
		
		if(cur != 0)flag = false;
		
		if(flag == false)
		{
			out.println("Impossible");
		}
		else
		{
			Stack<Character> s = new Stack<>();
			int ret = 0;
			for(char ch:arr)
			{
				if(ch=='(' || ch == '[' || ch == '{' || ch == '<')
				{
					s.push(ch);
				}
				else
				{
					char my = s.pop();
					if(ch == ')')
					{
						if(my != '(')
						{
							ret++;
						}
					}
					else if(ch == ']')
					{
						if(my != '[')
						{
							ret++;
						}
					}
					else if(ch == '>')
					{
						if(my != '<')
						{
							ret++;
						}
					}
					if(ch == '}')
					{
						if(my != '{')
						{
							ret++;
						}
					}
				}
			}
			out.println(ret);
		}
		
		out.close();
	}
	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}
		
		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}
	public static int[] sort(int[] arr)
	{
		List<Integer> temp = new ArrayList();
		for(int i:arr)temp.add(i);
		Collections.sort(temp);
		int start = 0;
		for(int i:temp)arr[start++]=i;
		return arr;
	}
	public static String rev(String str)
	{
		char[] arr = str.toCharArray();
		char[] ret = new char[arr.length];
		int start = arr.length-1;
		for(char i:arr)ret[start--] = i;
		String ret1 = "";
		for(char ch:ret)ret1+=ch;
		return ret1;
	}
}