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.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;


public class Main {

//    private static int f(C a, C b) {
//        
//        double d = Math.sqrt(d);
//        return 0;
//    }
//
//
//    
//    
    static class C{
        
        int x;
        int y;
        public C(int x, int y){
            this.x=x;
            this.y=y;
        }
    }
    
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new PrintWriter(System.out));
        
        String s = br.readLine();
        
        int n = s.length();
        
        if(s.charAt(0)==']' || s.charAt(0)=='}' || s.charAt(0)=='>' || s.charAt(0)==')') {
            System.out.println("Impossible");
        }else{
            boolean bad = false;
            Stack<Character> S = new Stack();
            
            int i = 0;
            int cnt = 0;
            while(i < n){
                
                //pick all left
                while(i < n && (s.charAt(i)=='[' || s.charAt(i)=='{' || s.charAt(i)=='<' || s.charAt(i)=='(') ){
                    S.add(s.charAt(i));
                    i+=1;
                }
                
                if(i==n || (S.isEmpty()&&i<n) ){
                    bad = true;
                    break;
                }
                
                
                //pick all right
                while(i < n &&  (s.charAt(i)==']' || s.charAt(i)=='}' || s.charAt(i)=='>' || s.charAt(i)==')') ){
                    if(S.isEmpty()){
                        bad=true;
                        break;
                    }
                    char t = S.pop();
                    
                    //System.out.println("matching "+(int)t+" "+(int)s.charAt(i)+" "+i);
                    if((t=='[' && s.charAt(i)!=']') || (t=='<' && s.charAt(i)!='>') || (t=='{' && s.charAt(i)!='}') || (t=='(' && s.charAt(i)!=')'))    cnt+=1;
                    
                    i+=1;
                }
                
                
                
                
            }
            
            if(bad || S.isEmpty()==false)   System.out.println("Impossible");
            else    System.out.println(cnt);
        }
        
        bw.close();
    }

    
    
}
//L65644020
    //20151UYO31284713