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 double eps = 1e-8;
const double inf = 1e20;
const double pi = 4 * atan(1);
int sgn(double x) { return x < -eps ? -1 : x > eps; }
struct point {
  double x, y;
  point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
  point operator+(const point &p) { return point(x + p.x, y + p.y); }
  point operator-(const point &p) { return point(x - p.x, y - p.y); }
  point operator*(const point &p) {
    double rx = x * p.x - y * p.y;
    double ry = x * p.y + y * p.x;
    return point(rx, ry);
  }
  point operator/(const point &p) {
    double rx = (x * p.x + y * p.y) / (p.x * p.x + p.y * p.y);
    double ry = (-x * p.y + y * p.x) / (p.x * p.x + p.y * p.y);
    return point(rx, ry);
  }
  point operator*(double t) { return point(x * t, y * t); }
  point operator/(double t) { return point(x / t, y / t); }
  double abs() { return sqrt(x * x + y * y); }
  double abs2() { return x * x + y * y; }
  double arg() { return atan2(y, x); }
};
point polar(double len, double al) {
  return point(len * cos(al), len * sin(al));
}
double dist(point a, point b) { return hypot(a.x - b.x, a.y - b.y); }
double dot(point a, point b) { return a.x * b.x + a.y * b.y; }
double multi(point a, point b) { return a.x * b.y - a.y * b.x; }
double multi(point a, point b, point o) { return multi(a - o, b - o); }
double angle(point a, point b) {
  double res = dot(a, b) / a.abs() / b.abs();
  res = max(res, -1.0);
  res = min(res, 1.0);
  res = acos(res);
  return res;
}
double p2sdist(point o, point a, point b) {
  if (sgn(dot(o - a, b - a)) <= 0) return dist(o, a);
  if (sgn(dot(o - b, a - b)) <= 0) return dist(o, b);
  return fabs(multi(a - o, b - o)) / dist(a, b);
}
bool onseg(point o, point a, point b) {
  if (sgn(multi(a - o, b - o))) return false;
  if (sgn(dot(a - o, b - o)) > 0) return false;
  return true;
}
double area(point *p, int n) {
  double res = 0;
  for (int i = 1; i < n - 1; i++) res += multi(p[i] - p[0], p[i + 1] - p[0]);
  return fabs(res) / 2;
}
bool parallel(point a, point b, point c, point d) {
  return sgn(multi(a - b, c - d)) == 0;
}
bool intersect(point a, point b, point c, point d) {
  if (min(a.x, b.x) > max(c.x, d.x) + eps) return false;
  if (min(a.y, b.y) > max(c.y, d.y) + eps) return false;
  if (min(c.x, d.x) > max(a.x, b.x) + eps) return false;
  if (min(c.y, d.y) > max(a.y, b.y) + eps) return false;
  if (sgn(multi(c - a, b - a)) * sgn(multi(d - a, b - a)) > 0) return false;
  if (sgn(multi(a - d, c - d)) * sgn(multi(b - d, c - d)) > 0) return false;
  return true;
}
int inside(point *p, int n, point a) {
  int i;
  for (i = 0; i < n; i++)
    if (onseg(a, p[i], p[(i + 1) % n])) return 0;
  double al = 0, be;
  for (i = 0; i < n; i++) {
    be = angle(p[i] - a, p[(i + 1) % n] - a);
    if (sgn(multi(p[i] - a, p[(i + 1) % n] - a)) > 0)
      al += be;
    else
      al -= be;
  }
  if (fabs(al) > 1)
    return 1;
  else
    return -1;
}
point a[300];
int dp[300][300], con[300][300];
int main() {
  int n;
  scanf("%d", &n);
  for (int i = 0; i < n; i++) scanf("%lf%lf", &a[i].x, &a[i].y);
  for (int i = 0; i < n; i++)
    for (int j = i + 1; j < n; j++) {
      point md = (a[i] + a[j]) / 2;
      if (inside(a, n, md) == 1) con[i][j] = con[j][i] = true;
      for (int k = 0; k < n; k++) {
        if (k == i || k == j) continue;
        if ((k + 1) % n == i || (k + 1) % n == j) continue;
        if (intersect(a[i], a[j], a[k], a[(k + 1) % n])) con[i][j] = false;
      }
      con[j][i] = con[i][j];
    }
  for (int i = 0; i < n; i++) con[i][(i + 1) % n] = con[(i + 1) % n][i] = true;
  for (int i = 0; i < n; i++) dp[i][1] = 1;
  for (int k = 2; k < n; k++) {
    for (int l = 0; l < n; l++) {
      int r = (l + k) % n;
      if (!con[l][r]) continue;
      for (int i = 1; i < k; i++) {
        if (con[l][(l + i) % n] && con[(l + i) % n][r]) {
          dp[l][k] += (long long)dp[l][i] * dp[(l + i) % n][k - i] % 1000000007;
          dp[l][k] %= 1000000007;
        }
      }
    }
  }
  printf("%d\n", dp[0][n - 1]);
  return 0;
}
