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;
double INF = 1e100, EPS = 1e-12;
struct PT {
  double x, y;
  PT() {}
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT& p) : x(p.x), y(p.y) {}
  PT operator+(const PT& p) const { return PT(x + p.x, y + p.y); }
  PT operator-(const PT& p) const { return PT(x - p.x, y - p.y); }
  PT operator*(double c) const { return PT(x * c, y * c); }
  PT operator/(double c) const { return PT(x / c, y / c); }
};
ostream& operator<<(ostream& os, const PT& p) {
  return os << "(" << p.x << "," << p.y << ")";
}
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
inline bool LinesParallel(PT a, PT b, PT c, PT d) {
  return fabs(cross(b - a, c - d)) < EPS;
}
inline bool LinesCollinear(PT a, PT b, PT c, PT d) {
  return LinesParallel(a, b, c, d) && fabs(cross(a - b, a - c)) < EPS &&
         fabs(cross(c - d, c - a)) < EPS;
}
inline bool SegmentsIntersect(PT a, PT b, PT c, PT d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dist2(a, c) < EPS || dist2(a, d) < EPS || dist2(b, c) < EPS ||
        dist2(b, d) < EPS)
      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;
}
double ComputeSignedArea(PT* p, int n) {
  double area = 0;
  for (int i = 0; i < n; i++) {
    int j = (i + 1) % n;
    area += p[i].x * p[j].y - p[j].x * p[i].y;
  }
  return area / 2.0;
}
int n;
PT pt[205];
bool valid[205][205];
void generateValid() {
  for (int i = 0; i <= n; i++) {
    for (int j = 0; j <= n; j++) {
      if (i % n == j % n) continue;
      valid[i][j] = true;
      for (int i_ = 0; i_ < n; i_++) {
        int j_ = (i_ + 1) % n;
        if (i % n == i_ % n || j % n == j_ % n) continue;
        if (i % n == j_ % n || j % n == i_ % n) continue;
        if (SegmentsIntersect(pt[i], pt[j], pt[i_], pt[j_]))
          valid[i][j] = false;
      }
    }
  }
}
inline bool isValid(int a, int b, int c) {
  return valid[a][b] && valid[b][c] && valid[c][a];
}
int DP[205][205][205];
int dp(int a, int b, int c) {
  if (b + 1 >= c) return 1;
  if (DP[a][b][c] >= 0) return DP[a][b][c];
  long long total = 0;
  for (int i = b + 1; i <= c; i++) {
    if (!isValid(a, b, i)) continue;
    if (cross(pt[b] - pt[a], pt[i] - pt[a]) <= EPS) continue;
    total += (long long)dp(i, b, i) * dp(a, i, c) % 1000000007;
  }
  return DP[a][b][c] = total % 1000000007;
}
int main() {
  scanf(" %d", &n);
  for (int i = 0; i < n; i++) {
    int x, y;
    scanf(" %d %d", &x, &y);
    pt[i] = PT(x, y);
  }
  pt[n] = pt[0];
  if (ComputeSignedArea(pt, n + 1) < 0) reverse(pt, pt + (n + 1));
  generateValid();
  for (int i = 0; i <= n; i++)
    for (int j = 0; j <= n; j++)
      for (int k = 0; k <= n; k++) DP[i][j][k] = -1;
  printf("%d\n", dp(0, 1, n));
  return 0;
}
