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 Pt {
  long long x, y;
  Pt() {}
  Pt(long long x, long long y) : x(x), y(y) {}
  Pt operator-(const Pt& a) { return Pt(x - a.x, y - a.y); }
  long long dot(const Pt& a) { return x * a.x + y * a.y; }
  long long det(const Pt& a) { return x * a.y - y * a.x; }
};
int sig(long long x) {
  if (x > 0) return +1;
  if (x < 0) return -1;
  return 0;
}
int iSP(Pt a, Pt b, Pt c) {
  int s = sig((b - a).det(c - a));
  if (s) return s;
  if (sig((b - a).dot(c - a)) < 0) return -2;
  if (sig((a - b).dot(c - b)) < 0) return +2;
  return 0;
}
bool iSS(Pt a, Pt b, Pt c, Pt d) {
  return (iSP(a, b, c) * iSP(a, b, d) <= 0 && iSP(c, d, a) * iSP(c, d, b) <= 0);
}
int sGP(int n, Pt p[], Pt a) {
  int side = -1, i;
  p[n] = p[0];
  for (i = 0; i < n; ++i) {
    Pt p0 = p[i] - a, p1 = p[i + 1] - a;
    if (sig(p0.det(p1)) == 0 && sig(p0.dot(p1)) <= 0) return 0;
    if (p0.y > p1.y) swap(p0, p1);
    if (sig(p0.y) <= 0 && 0 < sig(p1.y) && sig(p0.det(p1)) > 0) side = -side;
  }
  return side;
}
long long A;
long long S[201], T[201];
int best, cnt;
int N, X[201], Y[201];
Pt P[201];
struct comp_dist {
  Pt o;
  comp_dist(Pt o) : o(o) {}
  bool operator()(const Pt& p, const Pt& q) {
    int pp = abs(p.x - o.x) + abs(p.y - o.y);
    int qq = abs(q.x - o.x) + abs(q.y - o.y);
    return pp < qq;
  }
};
bool able[201][201];
long long mod = 1000000007;
long long F[201][201];
long long f(int L, int R) {
  if ((L + 1) % N == R) return 1;
  if ((L + 2) % N == R) return 1;
  long long& ret = F[L][R];
  if (ret != -1) return ret;
  ret = 0;
  for (int i = L + 1; i != R; i = (i + 1) % N)
    if (able[L][i] && able[i][R]) {
      ret += f(L, i) * f(i, R);
      ret %= mod;
    }
  return ret;
}
int MAIN() {
  scanf("%d", &N);
  for (int i = 0; i < N; ++i) {
    scanf("%d%d", &X[i], &Y[i]);
    P[i] = Pt(X[i] * 2, Y[i] * 2);
  }
  for (int i = 0; i < N; ++i) {
    for (int j = i; j < N; ++j) {
      bool ok = true;
      vector<Pt> Q;
      for (int k = 0; k < N; ++k) {
        int kk = (k + 1) % N;
        if (iSP(P[i], P[j], P[k]) == 0 || iSP(P[i], P[j], P[kk]) == 0) continue;
        if (iSS(P[i], P[j], P[k], P[kk])) ok = false;
      }
      if (ok)
        for (int k = 0; k < N; ++k)
          if (k != i && k != j)
            if (iSP(P[i], P[j], P[k]) == 0) ok = false;
      if (ok) {
        for (int k = 0; k < N; ++k) {
          if (i != j && iSP(P[i], P[j], P[k]) == 0) {
            Q.push_back(P[k]);
          }
        }
        sort(Q.begin(), Q.end(), comp_dist(P[i]));
        for (int k = 0; k + 1 < Q.size(); ++k) {
          Pt p(Q[k].x + Q[k + 1].x, Q[k].y + Q[k + 1].y);
          p.x /= 2;
          p.y /= 2;
          ok &= sGP(N, P, p) != -1;
        }
      }
      if (i == j) ok = true;
      if (i == (j + 1) % N) ok = true;
      if (j == (i + 1) % N) ok = true;
      if (ok) {
        able[i][j] = true;
        able[j][i] = true;
      }
    }
  }
  memset(F, 0xff, sizeof(F));
  int ans = f(0, N - 1);
  printf("%d\n", ans);
  return 0;
}
int main() {
  cout << fixed << setprecision(16);
  return MAIN();
}
