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 <class _T>
inline _T sqr(const _T& x) {
  return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
  ostringstream os("");
  os << a;
  return os.str();
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-11;
const int MOD = 1000000007;
struct tp {
  int x, y;
};
int n;
tp a[256];
int d[256][256];
bool g[256][256];
inline void add(int& a, int b) {
  a += b;
  if (a >= MOD) a -= MOD;
}
signed long long vp(tp p, tp p1, tp p2) {
  p1.x -= p.x;
  p1.y -= p.y;
  p2.x -= p.x;
  p2.y -= p.y;
  return p1.x * (signed long long)p2.y - p1.y * (signed long long)p2.x;
}
signed long long sp(tp p, tp p1, tp p2) {
  p1.x -= p.x;
  p1.y -= p.y;
  p2.x -= p.x;
  p2.y -= p.y;
  return p1.x * (signed long long)p2.x + p1.y * (signed long long)p2.y;
}
bool segseg(tp p1, tp p2, tp p3, tp p4) {
  if (max(min(p1.x, p2.x), min(p3.x, p4.x)) >
      min(max(p1.x, p2.x), max(p3.x, p4.x)))
    return false;
  if (max(min(p1.y, p2.y), min(p3.y, p4.y)) >
      min(max(p1.y, p2.y), max(p3.y, p4.y)))
    return false;
  signed long long d1 = vp(p1, p2, p3);
  signed long long d2 = vp(p1, p2, p4);
  if ((d1 < 0 && d2 < 0) || (d1 > 0 && d2 > 0)) return false;
  d1 = vp(p3, p4, p1);
  d2 = vp(p3, p4, p2);
  if ((d1 < 0 && d2 < 0) || (d1 > 0 && d2 > 0)) return false;
  return true;
}
bool inside(tp* a, int n, tp p) {
  int cnt = 0;
  for (int i = 0; i < (int)(n); i++) {
    if (a[i].y <= p.y && a[i + 1].y > p.y) {
      if (vp(a[i], a[i + 1], p) > 0) cnt++;
    } else if (a[i].y > p.y && a[i + 1].y <= p.y) {
      if (vp(a[i], a[i + 1], p) < 0) cnt++;
    }
  }
  return cnt % 2 == 1;
}
int main() {
  cout << setiosflags(ios::fixed) << setprecision(10);
  scanf("%d", &n);
  for (int i = 0; i < (int)(n); i++) {
    scanf("%d%d", &a[i].x, &a[i].y);
    a[i].x *= 2;
    a[i].y *= 2;
  }
  a[n] = a[0];
  signed long long s = 0;
  tp p0 = {x : 0, y : 0};
  for (int i = 0; i < (int)(n); i++) {
    s += vp(p0, a[i], a[i + 1]);
  }
  if (s < 0) {
    reverse(a, a + n);
    a[n] = a[0];
  }
  int ans = 0;
  memset((g), 0, sizeof(g));
  for (int i = 0; i < (int)(n); i++) {
    for (int j = (i + 2); j <= (int)(n); j++) {
      if (j - i >= n - 1) continue;
      g[i][j] = true;
      for (int l = 0; l < (int)(n); l++) {
        if (l != i && l != j) {
          if (segseg(a[i], a[j], a[l], a[l])) {
            g[i][j] = false;
            break;
          }
        }
        tp pp = {x : (a[i].x + a[j].x) / 2, y : (a[i].y + a[j].y) / 2};
        if (!inside(a, n, pp)) {
          g[i][j] = false;
          break;
        }
        if (l == i || (l + 1) % n == i || l == j || (l + 1) % n == j % n)
          continue;
        if (segseg(a[i], a[j], a[l], a[l + 1])) {
          g[i][j] = false;
          break;
        }
      }
    }
    g[i][i + 1] = true;
    d[i][i + 1] = 1;
  }
  for (int i = (n)-1; i >= 0; i--) {
    for (int j = (i + 1); j <= (int)(n - 1); j++) {
      int cnt = j - i + 1;
      if (cnt < 2) continue;
      if (cnt == 3)
        d[i][j] = 1;
      else {
        for (int l = (i + 1); l <= (int)(j - 1); l++) {
          if (g[i][l] && g[l][j]) {
            add(d[i][j], d[i][l] * (signed long long)d[l][j] % MOD);
          }
        }
      }
    }
  }
  ans = d[0][n - 1];
  printf("%d\n", ans);
  return 0;
}
