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;
const int MAX = 2e6 + 5, MOD = 1e9 + 7, MAXLG = log2(MAX) + 1;
const long long inf = 1e18 + 5;
struct point {
  long long x, y;
  point() {}
  point(long long x, long long y) : x(x), y(y) {}
  point operator-(const point &p) const { return point(x - p.x, y - p.y); }
};
long long dot(point p, point q) { return ((p.x * q.x) + (p.y * q.y)); }
long long cross(point p, point q) {
  long long ret = ((p.x * q.y) - (p.y * q.x));
  if (ret < 0) return -1;
  return (ret > 0 ? 1 : 0);
}
long long dist(point p, point q) { return dot(p - q, p - q); }
long long triangleArea(point a, point b, point c) {
  long long ret = ((a.x * b.y) + (b.x * c.y) + (c.x * a.y)) -
                  ((a.x * c.y) + (c.x * b.y) + (b.x * a.y));
  return abs(ret);
}
long long polygonArea(vector<point> &P) {
  long long ret = 0;
  int n = (int)P.size();
  for (int i = 0; i < n; i++) {
    ret += ((P[i].x * P[(i + 1) % n].y) - (P[(i + 1) % n].x * P[i].y));
  }
  return abs(ret);
}
bool pointsCollinear(point a, point b, point c) {
  long long triangle = triangleArea(a, b, c);
  if (triangle) return false;
  if (a.x >= min(b.x, c.x) && a.x <= max(b.x, c.x) && a.y >= min(b.y, c.y) &&
      a.y <= max(b.y, c.y))
    return true;
  return false;
}
bool linesParallel(point a, point b, point c, point d) {
  return abs(cross(b - a, c - d)) == 0;
}
bool linesCollinear(point a, point b, point c, point d) {
  return linesParallel(a, b, c, d) && abs(cross(a - b, a - c)) == 0 &&
         abs(cross(c - d, c - a)) == 0;
}
bool linesIntersect(point a, point b, point c, point d) {
  if (linesCollinear(a, b, c, d)) {
    if (!dist(a, c) || !dist(a, d) || !dist(b, c) || !dist(b, d)) return true;
    if (dot(c - a, c - b) > 0 && dot(d - a, d - b) > 0 && dot(c - b, d - b) > 0)
      return false;
    return true;
  }
  if (cross(d - a, b - a) * cross(c - a, b - a) > 0) return false;
  if (cross(a - c, d - c) * cross(b - c, d - c) > 0) return false;
  return true;
}
vector<point> P;
int n;
long long area;
bool possible(int L, int R) {
  for (int i = 0; i < n; i++) {
    if (i == L || i == R) continue;
    if (pointsCollinear(P[i], P[L], P[R])) return false;
  }
  for (int i = 0; i < n; i++) {
    if (i == L || i == R || (i + 1) % n == L || (i + 1) % n == R) continue;
    if (linesIntersect(P[L], P[R], P[i], P[(i + 1) % n])) return false;
  }
  vector<point> v;
  for (int i = L; i <= R; i++) v.push_back(P[i]);
  long long got = polygonArea(v);
  v.clear();
  for (int i = R; v.empty() || i != (L + 1) % n; i = (i + 1) % n)
    v.push_back(P[i]);
  got += polygonArea(v);
  return (got == area);
}
bool valid[205][205];
long long dp[205][205];
long long solve(int L, int R) {
  if (L + 1 == R) return 1;
  if (dp[L][R] != -1) return dp[L][R];
  long long ret = 0;
  for (int mid = L + 1; mid < R; mid++) {
    if (valid[L][mid] && valid[mid][R]) {
      long long temp = (solve(L, mid) * solve(mid, R)) % MOD;
      ret = (ret + temp) % MOD;
    }
  }
  return dp[L][R] = ret;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  ;
  cin >> n;
  for (int i = 0; i < n; i++) {
    int x, y;
    cin >> x >> y;
    P.push_back(point(x, y));
  }
  area = polygonArea(P);
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (possible(i, j)) valid[i][j] = valid[j][i] = true;
    }
  }
  memset(dp, -1, sizeof dp);
  long long ans = solve(0, n - 1);
  cout << ans << "\n";
}
