This time our child has a simple polygon. He has to find the number of ways to split the polygon into non-degenerate triangles, each way must satisfy the following requirements:

  * each vertex of each triangle is one of the polygon vertex; 
  * each side of the polygon must be the side of exactly one triangle; 
  * the area of intersection of every two triangles equals to zero, and the sum of all areas of triangles equals to the area of the polygon; 
  * each triangle must be completely inside the polygon; 
  * each side of each triangle must contain exactly two vertices of the polygon. 



The picture below depicts an example of a correct splitting.

<image>

Please, help the child. Calculate the described number of ways modulo 1000000007 (109 + 7) for him.

Input

The first line contains one integer n (3 ≤ n ≤ 200) — the number of vertices of the polygon. Then follow n lines, each line containing two integers. The i-th line contains xi, yi (|xi|, |yi| ≤ 107) — the i-th vertex of the polygon in clockwise or counterclockwise order.

It's guaranteed that the polygon is simple.

Output

Output the number of ways modulo 1000000007 (109 + 7).

Examples

Input

4
0 0
0 1
1 1
1 0


Output

2


Input

4
0 0
1 0
0 1
-1 0


Output

1


Input

5
0 0
1 0
1 1
0 1
-2 -1


Output

3

Note

In the first sample, there are two possible splittings:

<image>

In the second sample, there are only one possible splitting:

<image>
#include <bits/stdc++.h>
using namespace std;
struct Pt {
  long long x, y;
  Pt(long long x = 0, long long y = 0) : x(x), y(y) {}
  friend bool operator==(Pt a, Pt b) {
    return make_pair(a.x, a.y) == make_pair(b.x, b.y);
  }
};
int ccw(Pt a, Pt b, Pt c) {
  long long sum = 0;
  sum += a.x * (b.y - c.y);
  sum += b.x * (c.y - a.y);
  sum += c.x * (a.y - b.y);
  return (sum > 0) - (sum < -0);
}
long long tri_area(Pt a, Pt b, Pt c) {
  long long sum = 0;
  sum += a.x * (b.y - c.y);
  sum += b.x * (c.y - a.y);
  sum += c.x * (a.y - b.y);
  return sum;
}
bool point_in_segment(Pt p, Pt a, Pt b) {
  if (ccw(a, b, p) != 0) return false;
  if (min(a.x, b.x) <= p.x && p.x <= max(a.x, b.x))
    if (min(a.y, b.y) < p.y && p.y < max(a.y, b.y)) return true;
  if (min(a.x, b.x) < p.x && p.x < max(a.x, b.x))
    if (min(a.y, b.y) <= p.y && p.y <= max(a.y, b.y)) return true;
  return false;
}
bool intersects(Pt a, Pt b, Pt c, Pt d) {
  if (a == c || a == d || b == c || b == d) return false;
  if (ccw(a, b, c) * ccw(a, b, d) < 0)
    if (ccw(c, d, a) * ccw(c, d, b) < 0) return true;
  return false;
}
const long long mod = 1000000007;
const int MAXN = 210;
long long dp[MAXN][MAXN];
int good[MAXN][MAXN];
int n;
Pt pts[MAXN];
int main(void) {
  scanf("%d", &n);
  for (int i = (0); i < (n); ++i) {
    int x, y;
    scanf("%d %d", &x, &y);
    pts[i] = Pt(x, y);
  }
  long long area = 0;
  Pt origin(0, 0);
  for (int i = (0); i < (n); ++i) {
    area += tri_area(origin, pts[i], pts[(i + 1) % n]);
  }
  if (area < 0) reverse(pts, pts + n);
  for (int a = (0); a < (n); ++a)
    for (int b = (0); b < (n); ++b) {
      int& ref = good[a][b];
      ref = true;
      if (a == b) {
        ref = false;
        continue;
      }
      for (int x = (0); x < (n); ++x) {
        int y = (x + 1) % n;
        if (intersects(pts[a], pts[b], pts[x], pts[y])) ref = false;
        if (point_in_segment(pts[x], pts[a], pts[b])) ref = false;
        if (point_in_segment(pts[y], pts[a], pts[b])) ref = false;
      }
    }
  memset(dp, 0, sizeof dp);
  for (int i = (0); i < (n); ++i) dp[i][(i + 1) % n] = 1;
  for (int L = (2); L < (n); ++L) {
    for (int a = (0); a < (n); ++a) {
      int b = (a + L) % n;
      dp[a][b] = 0;
      for (int prvi = (1); prvi < (L); ++prvi) {
        int c = (a + prvi) % n;
        if (ccw(pts[a], pts[c], pts[b]) <= 0) continue;
        if (good[a][c] && good[b][c]) {
          dp[a][b] += dp[a][c] * dp[c][b];
          dp[a][b] %= mod;
        }
      }
    }
  }
  long long ans = 0;
  int a = 0, b = 1;
  for (int c = (2); c < (n); ++c) {
    if (ccw(pts[a], pts[b], pts[c]) > 0) {
      if (good[a][c] && good[b][c]) {
        ans += dp[1][c] * dp[c][0];
        ans %= mod;
      }
    }
  }
  printf(
      "%I64d"
      "\n",
      ans);
  return 0;
}
