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, typename U>
inline void smin(T &a, U b) {
  if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
  if (a < b) a = b;
}
int sgn(double first) { return first < -1e-7 ? -1 : first > 1e-7; }
struct point {
  double first, second;
  point(double _x = 0, double _y = 0) : first(_x), second(_y) {}
  point operator+(const point &p) {
    return point(first + p.first, second + p.second);
  }
  point operator-(const point &p) {
    return point(first - p.first, second - p.second);
  }
  point operator/(double t) { return point(first / t, second / t); }
  double abs() { return sqrt(first * first + second * second); }
};
double dot(point a, point b) { return a.first * b.first + a.second * b.second; }
double multi(point a, point b) {
  return a.first * b.second - a.second * b.first;
}
double multi(point a, point o, point b) { return multi(a - o, b - o); }
double angle(point a, point o, point b) {
  a = a - o, b = b - o;
  double res = dot(a, b) / a.abs() / b.abs();
  res = max(res, -1.0), res = min(res, 1.0);
  res = acos(res);
  if (multi(a, b) < 1e-7) res = -1 * res;
  return res;
}
bool onseg(point o, point a, point b) {
  if (sgn(multi(a - o, b - o))) return false;
  return dot(a - o, b - o) < 1e-7;
}
bool intersect(point a, point b, point c, point d) {
  return multi(a - b, c - b) * multi(a - b, d - b) < 1e-7 &&
         multi(c - d, a - d) * multi(c - d, b - d) < 1e-7 &&
         min(a.first, b.first) < max(c.first, d.first) + 1e-7 &&
         min(c.first, d.first) < max(a.first, b.first) + 1e-7 &&
         min(a.second, b.second) < max(c.second, d.second) + 1e-7 &&
         min(c.second, d.second) < max(a.second, b.second) + 1e-7;
}
int n, adj[210][210], vst[210][210], dp[210][210], i, j, k;
point m[210];
bool not_inside(int u, int v) {
  int i;
  point a = (m[u] + m[v]) / 2;
  for (i = 0; i < n; i++)
    if (onseg(a, m[i], m[i + 1])) return true;
  double Angle = 0, alpa;
  for (i = 0; i < n; i++) {
    alpa = angle(m[i], a, m[i + 1]);
    Angle += alpa;
  }
  if (fabs(Angle) > 2 * acos(-1) - 1e-7) return false;
  return true;
}
int calc(int st, int ed) {
  if (vst[st][ed]) return dp[st][ed];
  if (ed == st + 1) return 1;
  for (int i = st + 1; i < ed; i++) {
    if (adj[st][i] == 0 || adj[i][ed] == 0) continue;
    dp[st][ed] = (dp[st][ed] + 1ll * calc(st, i) * calc(i, ed) % 1000000007) %
                 1000000007;
  }
  vst[st][ed] = 1;
  return dp[st][ed];
}
int main() {
  scanf("%d", &n);
  for (i = 0; i < n; i++) scanf("%lf %lf", &m[i].first, &m[i].second);
  m[n] = m[0];
  for (i = 0; i < n; i++) {
    for (j = i + 2; j < n; j++) {
      if (not_inside(i, j)) continue;
      for (k = 0; k < n; k++) {
        if (k == i || k == j || (k + 1) % n == i || (k + 1) % n == j) continue;
        if (intersect(m[i], m[j], m[k], m[k + 1])) break;
      }
      if (k == n) adj[i][j] = 1;
    }
  }
  for (i = 0; i < n; i++) adj[i][i + 1] = 1;
  printf("%d\n", calc(0, n - 1));
  return 0;
}
