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() {}
  point(long long x, long long y) : x(x), y(y) {}
  point(const point &p) : x(p.x), y(p.y) {}
  point operator-(const point &p) const { return point(x - p.x, y - p.y); }
  long long triarea(point &b, point &c) {
    return (
        (x * b.y - y * b.x + b.x * c.y - b.y * c.x + c.x * y - c.y * x) < 0
            ? -(x * b.y - y * b.x + b.x * c.y - b.y * c.x + c.x * y - c.y * x)
            : (x * b.y - y * b.x + b.x * c.y - b.y * c.x + c.x * y - c.y * x));
  }
} P[205];
long long dot(point p, point q) { return p.x * q.x + p.y * q.y; }
long long dist2(point p, point q) { return dot(p - q, p - q); }
long long cross(point p, point q) {
  long long r = p.x * q.y - p.y * q.x;
  if (r < 0)
    return -1;
  else if (r > 0)
    return 1;
  return 0;
}
long long polygonArea(point v[], int n) {
  long long area = 0;
  for (int i = 0; i < n; i++)
    area += v[i].x * v[(i + 1) % n].y - v[i].y * v[(i + 1) % n].x;
  return ((area) < 0 ? -(area) : (area));
}
int n;
bool flag[205][205];
long long area;
bool colinearPoint(int i, int j, int k) {
  long long a = P[i].triarea(P[j], P[k]);
  if (a != 0) return false;
  if (P[i].x >= min(P[j].x, P[k].x) and P[i].x <= max(P[j].x, P[k].x) and
      P[i].y >= min(P[j].y, P[k].y) and P[i].y <= max(P[j].y, P[k].y))
    return true;
  return false;
}
bool LinesParallel(point a, point b, point c, point d) {
  return ((cross(b - a, c - d)) < 0 ? -(cross(b - a, c - d))
                                    : (cross(b - a, c - d))) == 0;
}
bool LinesCollinear(point a, point b, point c, point d) {
  return LinesParallel(a, b, c, d) &&
         ((cross(a - b, a - c)) < 0 ? -(cross(a - b, a - c))
                                    : (cross(a - b, a - c))) == 0 &&
         ((cross(c - d, c - a)) < 0 ? -(cross(c - d, c - a))
                                    : (cross(c - d, c - a))) == 0;
}
bool SegmentsIntersect(point a, point b, point c, point d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dist2(a, c) == 0 || dist2(a, d) == 0 || dist2(b, c) == 0 ||
        dist2(b, d) == 0)
      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;
}
bool possible(int l, int r) {
  for (int i = 0; i < n; i++)
    if (i != l and i != r and colinearPoint(i, l, r)) return false;
  for (int i = 0; i < n; i++)
    if (i != l and i != r and (i + 1) % n != l and (i + 1) % n != r and
        SegmentsIntersect(P[i], P[(i + 1) % n], P[l], P[r]))
      return false;
  point V[205];
  int sz = 0;
  for (int i = l; i <= r; i++) V[sz++] = P[i];
  long long sum = polygonArea(V, sz);
  sz = 0;
  for (int i = r; sz == 0 or i != (l + 1) % n; i++, i %= n) V[sz++] = P[i];
  sum += polygonArea(V, sz);
  return (sum == area);
}
long long dp[205][205];
const long long MOD = 1e9 + 7;
long long call(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 i = l + 1; i < r; i++)
    if (flag[l][i] and flag[i][r])
      ret = (ret + (call(l, i) * call(i, r)) % MOD) % MOD;
  return dp[l][r] = ret;
}
int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) scanf("%lld %lld", &P[i].x, &P[i].y);
  area = polygonArea(P, n);
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      flag[i][j] = flag[j][i] = possible(i, j);
    }
  }
  memset(dp, -1, sizeof(dp));
  printf("%lld\n", call(0, n - 1));
}
