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;
template <typename T>
T mabs(const T &a) {
  return a < 0 ? -a : a;
}
struct point {
  long long x, y;
  point(long long x0 = 0, long long y0 = 0) {
    x = x0;
    y = y0;
  }
  point operator*(const long long a) const { return point(a * x, a * y); }
  point operator+(const point &a) const { return point(x + a.x, y + a.y); }
  point operator-(const point &a) const { return point(x - a.x, y - a.y); }
  long long operator^(const point &a) const { return x * a.y - y * a.x; }
  double norm() const { return sqrt(x * x + y * y); }
};
int sign(long long a) {
  if (a == 0) return 0;
  return a < 0 ? -1 : 1;
}
int checkProj(long long a, long long b, long long c, long long d) {
  long long sta = min(a, b), enda = max(a, b);
  long long stc = min(c, d), endc = max(c, d);
  return sign(min(enda, endc) - max(sta, stc));
}
bool intersect(const point &a, const point &b, const point &c, const point &d) {
  long long pr1 = sign((b - a) ^ (c - a));
  long long pr2 = sign((b - a) ^ (d - a));
  long long pr3 = sign((d - c) ^ (b - c));
  long long pr4 = sign((d - c) ^ (a - c));
  if (pr1 == 0 && pr2 == 0 && pr3 == 0 && pr4 == 0) {
    int s1 = checkProj(a.x, b.x, c.x, d.x);
    int s2 = checkProj(a.y, b.y, c.y, d.y);
    return s1 >= 0 && s2 >= 0 && (s1 != 0 || s2 != 0);
  }
  long long s1 = pr1 * pr2;
  long long s2 = pr3 * pr4;
  return s1 <= 0 && s2 <= 0 && (s1 != 0 || s2 != 0);
}
const int mod = 1e9 + 7;
int D[202][202];
bool Can[201][201] = {0};
int dyn(int a, int b) {
  if (D[a][b] != -1) return D[a][b];
  int &res = D[a][b];
  if (b - a + 1 <= 3) return res = 1;
  res = 0;
  if (Can[a + 1][b]) {
    res = (res + dyn(a + 1, b)) % mod;
  }
  for (int mid = (a + 2), emid = (b); mid < emid; mid++) {
    if (Can[a][mid] && Can[mid][b]) {
      long long p1 = dyn(a, mid);
      long long p2 = dyn(mid, b);
      res = (res + p1 * p2) % mod;
    }
  }
  return res;
}
const double PI = acos(-1.0);
bool pointInside(point *P, int n, const point &a) {
  double sum = 0;
  const double eps = 1e-8;
  for (int i = (0), ei = (n); i < ei; i++) {
    point da = P[i] * 2 - a;
    point db = P[i + 1] * 2 - a;
    double cs = (da.x * db.x + da.y * db.y) / (da.norm() * db.norm());
    if (cs < -1) cs = -1;
    if (cs > 1) cs = 1;
    double v = acos(cs);
    if (sign(da ^ db) < 0)
      sum += v;
    else
      sum -= v;
  }
  sum = fabs(sum);
  return fabs(sum - 2 * PI) < eps;
}
void run() {
  memset(D, -1, sizeof(D));
  point P[202];
  int n;
  cin >> n;
  for (int i = (0), ei = (n); i < ei; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    P[i] = point(x, y);
  }
  P[n] = P[0];
  for (int i = (0), ei = (n); i < ei; i++)
    for (int j = (i + 1), ej = (n); j < ej; j++) {
      bool ok = true;
      for (int k = (0), ek = (n); k < ek; k++)
        if (intersect(P[i], P[j], P[k], P[k + 1])) ok = false;
      if (ok) {
        if (!pointInside(P, n, P[i] + P[j])) ok = false;
      }
      if (ok) {
        Can[i][j] = Can[j][i] = 1;
      }
    }
  for (int i = (0), ei = (n); i < ei; i++)
    Can[i][(i + 1) % n] = Can[(i + 1) % n][i] = 1;
  int res = dyn(0, n - 1);
  cout << res << endl;
}
int main() {
  run();
  return 0;
}
