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 Point {
  long long x, y;
  Point() : x(), y() {}
  Point(long long _x, long long _y) : x(_x), y(_y) {}
  Point operator+(Point A) { return Point(x + A.x, y + A.y); }
  Point operator-(Point A) { return Point(x - A.x, y - A.y); }
  Point operator*(long long a) { return Point(x * a, y * a); }
  Point operator/(long long a) { return Point(x / a, y / a); }
  long long operator%(Point A) { return x * A.x + y * A.y; }
  long long operator*(Point A) { return x * A.y - y * A.x; }
  double length() { return sqrt((double)(*this % *this)); }
  long long len2() { return *this % *this; }
  double distTo(Point A) { return (*this - A).length(); }
  bool onLine(Point A, Point B) { return (*this - A) * (B - A) == 0; }
  bool onSegm(Point A, Point B) {
    return onLine(A, B) && (*this - A) % (*this - B) <= 0;
  }
  void read() { scanf("%lld%lld", &x, &y); }
};
int sgn(long long x) {
  if (x < 0) return -1;
  if (x == 0) return 0;
  return 1;
}
bool oneSide(Point A, Point B, Point C, Point D) {
  int s1 = sgn((B - A) * (C - A));
  int s2 = sgn((B - A) * (D - A));
  if (s1 * s2 == 1) return true;
  return false;
}
bool isParallel(Point A, Point B, Point C, Point D) {
  return (B - A) * (D - C) == 0;
}
bool hasInter(Point A, Point B, Point C, Point D) {
  if (isParallel(A, B, C, D))
    return (C.onSegm(A, B) || D.onSegm(A, B) || A.onSegm(C, D) ||
            B.onSegm(C, D));
  return (!oneSide(A, B, C, D) && !oneSide(C, D, A, B));
}
const int mod = (int)1e9 + 7;
int add(int a, int b) { return (a + b) % mod; }
int mul(int a, int b) { return (a * 1LL * b) % mod; }
const int maxn = 205;
Point P[maxn];
int n;
bool isIn(Point X) {
  int cnt = 0;
  for (int i = 0; i < n; i++) {
    Point A = P[i];
    Point B = P[i + 1];
    if (X.onSegm(A, B)) return false;
    if (A.y == B.y) continue;
    if (A.y > B.y) swap(A, B);
    if (!(A.y <= X.y && X.y < B.y)) continue;
    long long day = X.y - A.y;
    long long dby = B.y - X.y;
    if (A.x * dby + B.x * day > X.x * (day + dby)) cnt++;
  }
  return cnt % 2;
}
bool cd[maxn][maxn];
int dp[maxn][maxn];
bool used[maxn][maxn];
int solve(int l, int r) {
  if (used[l][r]) return dp[l][r];
  used[l][r] = true;
  if (r - l <= 2) return dp[l][r] = 1;
  int ans = 0;
  if (cd[l + 1][r]) {
    ans = add(ans, solve(l + 1, r));
  }
  for (int i = r - 1; i >= l + 2; i--) {
    if (cd[l][i] && (i == r - 1 || cd[r][i])) {
      ans = add(ans, mul(solve(l, i), solve(i, r)));
    }
  }
  return dp[l][r] = ans;
}
int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
    P[i].read();
    P[i] = P[i] * 2;
  }
  P[n] = P[0];
  for (int i = 0; i < n; i++)
    for (int j = i + 2; j < (i == 0 ? n - 1 : n); j++) {
      bool good = isIn((P[i] + P[j]) / 2);
      for (int h = 0; h < n && good; h++) {
        int hh = (h + 1) % n;
        if (h == i || h == j || hh == i || hh == j) continue;
        if (hasInter(P[i], P[j], P[h], P[hh])) {
          good = false;
        }
      }
      cd[i][j] = cd[j][i] = good;
    }
  int ans = solve(0, n - 1);
  printf("%d\n", ans);
  return 0;
}
