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 int INF = 1e9 + 10;
const long long int INFLL = 1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-14;
const long long int MOD = 1000000007;
template <class T>
T &chmin(T &a, const T &b) {
  return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
  return a = max(a, b);
}
pair<long long int, long long int> operator-(
    const pair<long long int, long long int> &a,
    const pair<long long int, long long int> &b) {
  return pair<long long int, long long int>(a.first - b.first,
                                            a.second - b.second);
}
inline long long int det(const pair<long long int, long long int> &a,
                         const pair<long long int, long long int> &b) {
  return a.first * b.second - a.second * b.first;
}
inline long long int dot(const pair<long long int, long long int> &a,
                         const pair<long long int, long long int> &b) {
  return a.first * b.first + a.second * b.second;
}
inline int ccw(pair<long long int, long long int> a,
               pair<long long int, long long int> b,
               pair<long long int, long long int> c) {
  long long int detc = det(b - a, c - a);
  if (detc > 0) return 1;
  if (detc < 0) return -1;
  return 0;
}
inline int ccw2(pair<long long int, long long int> a,
                pair<long long int, long long int> b,
                pair<long long int, long long int> c) {
  long long int detc = det(b - a, c - a);
  if (detc > 0) return 1;
  if (detc < 0) return -1;
  if (dot(b - a, c - a) <= 0) return 2;
  return 0;
}
inline bool cross(const pair<long long int, long long int> &a,
                  const pair<long long int, long long int> &b,
                  const pair<long long int, long long int> &c,
                  const pair<long long int, long long int> &d) {
  return ccw(a, c, b) * ccw(a, d, b) == -1 && ccw(c, a, d) * ccw(c, b, d) == -1;
}
struct Mod {
  unsigned n;
  Mod() {}
  Mod(long long int x) {
    if (x < 0)
      n = x % MOD + MOD;
    else
      n = x % MOD;
  }
};
Mod operator+(Mod a, Mod b) { return Mod(a.n + b.n); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-(Mod a, Mod b) { return Mod(a.n + MOD - b.n); }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*(Mod a, Mod b) { return Mod((long long int)a.n * b.n); }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod modpow(Mod x, long long int k) {
  Mod res = 1;
  while (k) {
    if (k & 1) res *= x;
    k /= 2;
    x *= x;
  }
  return res;
}
Mod inv(Mod a) { return modpow(a, MOD - 2); }
Mod operator/(Mod a, Mod b) { return Mod((long long int)a.n * inv(b).n); }
Mod operator/=(Mod &a, Mod b) { return a = a / b; }
const int MAX_N = 256;
int n;
bool cr[MAX_N][MAX_N];
int x[MAX_N];
int y[MAX_N];
pair<long long int, long long int> p[MAX_N];
Mod memo[MAX_N][MAX_N];
bool used[MAX_N][MAX_N];
bool isin(pair<long long int, long long int> pp) {
  pair<long long int, long long int> qq = pair<long long int, long long int>(
      (rand() % 200 - 100) * (long long int)INF,
      (rand() % 200 - 100) * (long long int)INF);
  int cnt = 0;
  for (int i = (0); i < (int)(n); i++)
    if (cross(pp, qq, p[i], p[(i + 1) % n])) cnt++;
  if (cnt % 2 == 1) return true;
  for (int i = (0); i < (int)(n); i++)
    if (ccw2(pp, p[i], p[(i + 1) % n]) == 2) return true;
  return false;
}
bool isin_rep(pair<long long int, long long int> pp) {
  int cnt = 0;
  for (int i = (0); i < (int)(10); i++)
    if (isin(pp)) cnt++;
  return cnt > 7;
}
Mod rec(int a, int b) {
  if (used[a][b]) return memo[a][b];
  used[a][b] = true;
  if (a + 2 >= b) return memo[a][b] = 1;
  Mod res = 0;
  for (int i = a + 1; i < b; i++) {
    if (!cr[a][i] && !cr[i][b]) res += rec(a, i) * rec(i, b);
  }
  return memo[a][b] = res;
}
int main() {
  srand(time(NULL));
  cin >> n;
  for (int i = (0); i < (int)(n); i++) cin >> x[i] >> y[i];
  for (int i = (0); i < (int)(n); i++) x[i] *= 2;
  for (int i = (0); i < (int)(n); i++) y[i] *= 2;
  for (int i = (0); i < (int)(n); i++)
    p[i] = pair<long long int, long long int>(x[i], y[i]);
  for (int i = (0); i < (int)(n); i++)
    for (int j = (0); j < (int)(n); j++) {
      for (int k = (0); k < (int)(n); k++)
        if (i != k && i != (k + 1) % n && j != k && j != (k + 1) % n &&
            !cr[i][j])
          cr[i][j] |= cross(p[i], p[j], p[k], p[(k + 1) % n]);
      for (int k = (0); k < (int)(n); k++)
        if (i != k && j != k && !cr[i][j] && ccw2(p[k], p[i], p[j]) == 2)
          cr[i][j] = true;
      if (!cr[i][j] &&
          !isin_rep(pair<long long int, long long int>(
              (p[i].first + p[j].first) / 2, (p[i].second + p[j].second) / 2)))
        cr[i][j] = true;
    }
  cout << rec(0, n - 1).n << endl;
  return 0;
}
