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.io.*;
import java.util.*;
  
public class Main implements Runnable {
  final boolean isFileIO = false; 
  BufferedReader in;
  PrintWriter out;
  StringTokenizer st = new StringTokenizer("");
  String delim = " ";

  public static void main(String[] args) {
    new Thread(null, new Main(), "", 268435456).start(); 
  }

  public void run() {
    try {
      initIO();
      solve();
      out.close();
    } catch(Exception e) {
      e.printStackTrace(System.err);
      System.exit(-1);
    }
  }

  public void initIO() throws IOException {
    if(!isFileIO) {
      in = new BufferedReader(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
    } else {
      in = new BufferedReader(new FileReader("input.txt"));
      out = new PrintWriter("output.txt"); 
    }
  }
  
  String nextToken() throws IOException {
    if(!st.hasMoreTokens()) {
      st = new StringTokenizer(in.readLine());
    }
    return st.nextToken(delim);
  }
 
  String readLine() throws IOException {
    return in.readLine();
  }

  int nextInt() throws IOException {
   return Integer.parseInt(nextToken());
  }

  long nextLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  double nextDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }
 
  int n;
  String[] s, ans;
  int[] x; 
 
  int check(long val) {
    // 1 less, 2 more
    for(int i = 0; i < n; i++) {
      if(s[i].equals(">")) {
        if(ans[i].equals("Y")){
          if(val <= x[i]) return 1;}
        else
          if(val > x[i]) return 2;
      }
      if(s[i].equals("<")) {
         if(ans[i].equals("Y")){
           if(val >= x[i]) return 2;}
         else
           if(val < x[i]) return 1;
      }
      if(s[i].equals(">=")) {
         if(ans[i].equals("Y")) {
           if(val < x[i]) return 1;}
         else
           if(val >= x[i]) return 2;
      }
      if(s[i].equals("<=")) {
        if(ans[i].equals("Y")){
          if(val > x[i]) return 2;}
        else
          if(val <= x[i]) return 1;
      }
    }
    return 0;
  }  

  void solve() throws IOException {
    n = nextInt();
    s = new String[n];
    x = new int[n];
    ans = new String[n];
    long left, right, mid;
    left = -2_000_000_000;
    right = 2_000_000_000;
    for(int i = 0; i < n; i++) {
      s[i] = nextToken();
      x[i] = nextInt();
      ans[i] = nextToken();
    }
    while(left < right) {
      mid = left + (right - left) / 2;
      int val = check(mid);
      if(val == 0) {
        out.println(mid);
        return;
      } else {
        if(val == 1) {
          left = mid + 1;
        } else 
          right = mid;
      }
    }
    out.println("Impossible");
  }

  class Group implements Comparable<Group> {
    public int c, p, n;

    public Group (int c, int p, int n) {
      this.c = c;
      this.p = p;
      this.n = n;
    }

    public int compareTo(Group y) {
      if(this.p > y.p) return -1;
      if(this.p < y.p) return 1;
      return 0;
    }
  } 

  class Table implements Comparable<Table> {
    public int r, n;
    
    public Table(int r, int n) {
      this.r = r;
      this.n = n;
    }
    
    public int compareTo(Table y) {
      if(this.r < y.r) return -1;
      if(this.r > y.r) return 1;
      return 0;
    }
  }
  void solve2() throws IOException {
    int n = nextInt();
    Group[] groups = new Group[n];
    for(int i = 0; i < n; i++) {
      groups[i] = new Group(nextInt(), nextInt(), i);
    }
    int k = nextInt();
    Table[] tables = new Table[k];
    for(int i = 0; i < k; i++) 
      tables[i] = new Table(nextInt(), i);
    Arrays.sort(groups);
    Arrays.sort(tables);
    int[] ans = new int[n];
    boolean[] isUsed = new boolean[k];
    Arrays.fill(ans, -1);
    for(int i = 0; i < n; i++) {
      for(int j = 0; j < k; j++) {
        if(tables[j].r >= groups[i].c && !isUsed[tables[j].n]) {
          ans[groups[i].n] = tables[j].n;
          isUsed[tables[j].n] = true;
          break;
        }
      }
    }
    int cnt = 0;
    int sum = 0;
    for(int i = 0; i < n; i++) {
      if(ans[groups[i].n] != -1) {
        cnt++;
        sum += groups[i].p;
      }
    }
    out.println(cnt + " " + sum);
    for(int i = 0; i < n; i++)
      if(ans[i] != -1)
        out.println((i + 1) + " " + (ans[i] + 1));
  }
}