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 PYTHON3):

Solution:
from enum import Enum
from collections import namedtuple

class Operator(Enum):
    LT = "<"
    LTE = "<="
    GT = ">"
    GTE = ">="

    def inverse(self):
        inverses = {
            self.LT: self.GTE,
            self.LTE: self.GT,
            self.GT: self.LTE,
            self.GTE: self.LT
        }

        return inverses[self]

Range = namedtuple('Range', ['op', 'number'])

def order_strictness_le_or_leq(a: Range):
    return (a.number, 0 if a.op == Operator.LT else 1)

def order_strictness_ge_or_geq(a: Range):
    return (a.number, 1 if a.op == Operator.GT else 0)

queries = int(input())
ranges_le_leq = [Range(op=Operator.LTE, number=2*(10**9))]
ranges_gt_gte = [Range(op=Operator.GTE, number=-2*(10**9))]

for i in range(queries):
    operator, number, answer = input().split()
    operator = Operator(operator)
    number = int(number)

    if answer == "N":
        operator = operator.inverse()
    
    r = Range(op=operator, number=number)
    if operator in [Operator.LT, Operator.LTE]:
        ranges_le_leq.append(r)
    else:
        ranges_gt_gte.append(r)

most_strict_lt = min(ranges_le_leq, key=order_strictness_le_or_leq)
most_strict_gt = max(ranges_gt_gte, key=order_strictness_ge_or_geq)

gt_number = most_strict_gt.number
if most_strict_gt.op == Operator.GT:
    gt_number += 1

lt_number = most_strict_lt.number
if most_strict_lt.op == Operator.LT:
    lt_number -= 1

if gt_number > lt_number:
    print("Impossible")
else:
    print(gt_number)