Problem: A TV show called "Guess a number!" is gathering popularity. The whole Berland, the old and the young, are watching the show.

The rules are simple. The host thinks of an integer y and the participants guess it by asking questions to the host. There are four types of acceptable questions:

  * Is it true that y is strictly larger than number x? 
  * Is it true that y is strictly smaller than number x? 
  * Is it true that y is larger than or equal to number x? 
  * Is it true that y is smaller than or equal to number x? 



On each question the host answers truthfully, "yes" or "no".

Given the sequence of questions and answers, find any integer value of y that meets the criteria of all answers. If there isn't such value, print "Impossible".

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 10000) — the number of questions (and answers). Next n lines each contain one question and one answer to it. The format of each line is like that: "sign x answer", where the sign is:

  * ">" (for the first type queries), 
  * "<" (for the second type queries), 
  * ">=" (for the third type queries), 
  * "<=" (for the fourth type queries). 



All values of x are integer and meet the inequation  - 109 ≤ x ≤ 109. The answer is an English letter "Y" (for "yes") or "N" (for "no").

Consequtive elements in lines are separated by a single space.

Output

Print any of such integers y, that the answers to all the queries are correct. The printed number y must meet the inequation  - 2·109 ≤ y ≤ 2·109. If there are many answers, print any of them. If such value doesn't exist, print word "Impossible" (without the quotes).

Examples

Input

4
&gt;= 1 Y
&lt; 3 N
&lt;= -3 N
&gt; 55 N


Output

17


Input

2
&gt; 100 Y
&lt; -100 Y


Output

Impossible

Solution (in JAVA):

Solution:
import java.util.*;
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;

public class A1
{
    FastScanner in;
    PrintWriter out;
    
    public void solve() throws IOException
    {
        int n = in.nextInt();
        
        int intervalLeft  = -2000000000;
        int intervalRight = 2000000000;
        
        boolean bGood = true;
        
        for(int i = 0; i < n; i++)
        {
            String  type = in.next();
            int     val  = in.nextInt();
            String   ans  = in.next();
            boolean bAns = ans.equals("Y") ? true : false;
            
            switch(type)
            {
                case ">=":
                    if(bAns)
                    {
                        if(val >= intervalLeft)
                            intervalLeft = val;
                    }
                    else
                    {
                        if(val <= intervalRight)
                            intervalRight = val - 1;
                    }
                break;
                
                case ">":
                    if(bAns)
                    {
                        if(val >= intervalLeft)
                            intervalLeft = val + 1;
                    }
                    else
                    {
                        if(val <= intervalRight)
                            intervalRight = val;
                    }
                break;
                
                case "<=":
                    if(bAns)
                    {
                        if(val <= intervalRight)
                            intervalRight = val;
                    }
                    else
                    {
                        if(val >= intervalLeft)
                            intervalLeft = val + 1;
                    }
                break;
                
                case "<":
                    if(bAns)
                    {
                        if(val <= intervalRight)
                            intervalRight = val - 1;
                    }   
                    else
                    {
                        if(val >= intervalLeft)
                            intervalLeft = val;
                    }
                break;
            }
            
            if(intervalLeft > intervalRight || bGood == false)
            {
                bGood = false;
                break;
            }
        }
        
        if(bGood)
            out.print(intervalLeft);
        else
            out.print("Impossible");
        
    }

    public void run()
    {
        try
        {
            in = new FastScanner();
            out = new PrintWriter(System.out);

            solve();

            out.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    class FastScanner
    {
        BufferedReader  br;
        StringTokenizer st;

        FastScanner()
        {

            br = new BufferedReader(new InputStreamReader(System.in));

        }

        FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            }
            catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        String next()
        {
            while (st == null || !st.hasMoreTokens())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        int[] nextIntArray(int size)
        {
            int[] array = new int[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextInt();
            }

            return array;
        }

        long[] nextLongArray(int size)
        {
            long[] array = new long[size];

            for (int i = 0; i < size; i++)
            {
                array[i] = nextLong();
            }

            return array;
        }

        BigInteger nextBigInteger()
        {
            return new BigInteger(next());
        }

        Point nextIntPoint()
        {
            int x = nextInt();
            int y = nextInt();
            return new Point(x, y);
        }

        Point[] nextIntPointArray(int size)
        {
            Point[] array = new Point[size];

            for (int index = 0; index < size; ++index)
            {
                array[index] = nextIntPoint();
            }

            return array;
        }

        List<Integer>[] readGraph(int vertexNumber, int edgeNumber, boolean undirected)
        {
            List<Integer>[] graph = new List[vertexNumber];

            for (int index = 0; index < vertexNumber; ++index)
            {
                graph[index] = new ArrayList<Integer>();
            }

            while (edgeNumber-- > 0)
            {
                int from = nextInt() - 1;
                int to = nextInt() - 1;

                graph[from].add(to);
                if (undirected)
                    graph[to].add(from);
            }

            return graph;
        }
    }

    public static void main(String[] arg)
    {
        new A1().run();
    }
}