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.Scanner;

/**
 * @author hersheys
 */
public class Main {

    private static class Range {

        private final long min;
        private final long max;

        private Range(long min, long max) {
            this.min = min;
            this.max = max;
        }

        public long getMin() {
            return min;
        }

        public long getMax() {
            return max;
        }

        /**
         * Returns the inverse of this range, sort of. Works enough for this question.
         */
        public Range invert() {
            if(min == Long.MIN_VALUE) {
                return new Range(max + 1, Long.MAX_VALUE);
            }
            if(max == Long.MAX_VALUE) {
                return new Range(Long.MIN_VALUE, min - 1);
            }
            throw new IllegalStateException("bug");
        }

        /**
         * Returns the intersection of these 2 ranges
         */
        public Range combine(Range r2) {
            long min = Math.max(this.min, r2.getMin());
            long max = Math.min(this.getMax(), r2.getMax());
            return new Range(min, max);
        }

        public boolean rangeIsPossible() {
            return min <= max;
        }

        @Override
        public String toString() {
            final StringBuffer sb = new StringBuffer("Range{");
            sb.append("min=").append(min);
            sb.append(", max=").append(max);
            sb.append('}');
            return sb.toString();
        }
    }

    /**
     * Given a condition returns a range that satisfies the condition.
     * @param condition
     * @return
     */
    private static Range buildRangeFromCondition(String condition) {
        String[] parts = condition.split(" ");
        String comparator = parts[0];
        long value = Long.parseLong(parts[1]);
        boolean expressionTrue = parts[2].equalsIgnoreCase("y");

        //first build a range of the question, we'll invert it if the answer was no
        long start;
        long end;
        if(comparator.contains(">")) {
            start = comparator.contains("=") ? value : value + 1;
            end = Long.MAX_VALUE;
        } else {
            start = Long.MIN_VALUE;
            end = comparator.contains("=") ? value : value - 1;
        }
        Range range = new Range(start, end);

        //flip the range if required
        if(!expressionTrue) {
            range = range.invert();
        }

        //System.out.println(range);

        return range;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int lines = Integer.parseInt(scanner.nextLine());

        Range range = new Range(Long.MIN_VALUE, Long.MAX_VALUE);
        for(int i = 0; i < lines; i++) {
            range = range.combine(buildRangeFromCondition(scanner.nextLine()));
            //System.out.println(range);
        }

        if(!range.rangeIsPossible()) {
            System.out.println("Impossible");
        } else {
            if(range.min == Long.MIN_VALUE) {
                System.out.println(range.getMax());
            } else {
                System.out.println(range.getMin());
            }
        }
    }

}