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 point {
  long long x, y;
  point(int _x, int _y) : x(_x), y(_y) {}
  point() {}
};
point operator+(point a, point b) { return point(a.x + b.x, a.y + b.y); }
point operator-(point a, point b) { return point(a.x - b.x, a.y - b.y); }
long long vect(point a, point b) { return (a.x) * b.y - (a.y) * b.x; }
long long scal(point a, point b) { return (a.x) * b.x + (a.y) * b.y; }
bool intersect(point a1, point a2, point b1, point b2) {
  if (vect(a2 - a1, b2 - b1) == 0) {
    if (vect(b1 - a1, a2 - a1) != 0) return false;
    long long l1, r1, l2, r2;
    if (a1.x != a2.x) {
      l1 = min(a1.x, a2.x);
      r1 = max(a1.x, a2.x);
      l2 = min(b1.x, b2.x);
      r2 = max(b1.x, b2.x);
    } else {
      l1 = min(a1.y, a2.y);
      r1 = max(a1.y, a2.y);
      l2 = min(b1.y, b2.y);
      r2 = max(b1.y, b2.y);
    }
    if (r1 < l2 || l1 > r2)
      return false;
    else
      return true;
  } else {
    long long s1 = vect(a2 - a1, b1 - a1), s2 = vect(a2 - a1, b2 - a1);
    long long s3 = vect(b2 - b1, a1 - b1), s4 = vect(b2 - b1, a2 - b1);
    if ((s1 < 0 && s2 < 0) || (s1 > 0 && s2 > 0) || (s3 < 0 && s4 < 0) ||
        (s3 > 0 && s4 > 0))
      return false;
    return true;
  }
}
point poly[210];
long long dinam[210][210];
bool alw[210][210];
bool in(point p, point l, point r) {
  return vect(r - l, p - l) == 0 && scal(p - l, r - l) >= 0 &&
         scal(p - r, l - r) >= 0;
}
long long sign(long long x) {
  if (x > 0) return 1;
  if (x < 0) return -1;
  return 0;
}
int main() {
  ios_base::sync_with_stdio(false);
  int n;
  cin >> n;
  for (int i = 0; i < n; i++) cin >> poly[i].x >> poly[i].y;
  long long sq = 0;
  for (int i = 0; i < n; i++) {
    sq += vect(poly[i], poly[(i + 1) % n]);
  }
  memset(dinam, 0, sizeof dinam);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      if (i == j) continue;
      alw[i][j] = true;
      for (int m = 0; m < n; m++) {
        int u = m, v = (m + 1) % n;
        if (u == i || u == j || v == i || v == j) continue;
        if (intersect(poly[i], poly[j], poly[u], poly[v])) alw[i][j] = false;
      }
      int ss = 0;
      for (int m = 0; m < n; m++) {
        ss += in(poly[m], poly[i], poly[j]);
      }
      if (ss != 2) alw[i][j] = false;
      int mn = (i + 1) % n, make_pair = (i - 1 + n) % n;
      if (vect(poly[mn] - poly[i], poly[make_pair] - poly[i]) == 0) {
        if (vect(poly[mn] - poly[i], poly[j] - poly[i]) * sign(sq) < 0)
          alw[i][j] = false;
      } else if (vect(poly[make_pair] - poly[i], poly[mn] - poly[i]) *
                     sign(sq) <
                 0) {
        if (!(sign(vect(poly[mn] - poly[i], poly[j] - poly[i])) * sign(sq) >=
                  0 &&
              sign(vect(poly[make_pair] - poly[i], poly[j] - poly[i])) *
                      sign(sq) <=
                  0))
          alw[i][j] = false;
      } else {
        if (sign(vect(poly[mn] - poly[i], poly[j] - poly[i])) * sign(sq) < 0 &&
            sign(vect(poly[make_pair] - poly[i], poly[j] - poly[i])) *
                    sign(sq) >
                0)
          alw[i][j] = false;
      }
    }
  }
  for (int r = 0; r < n; r++) {
    for (int l = r - 1; l >= 0; l--) {
      if (r == l + 1) dinam[l][r] = 1;
      for (int m = l + 1; m < r; m++) {
        if (alw[l][m] && alw[r][m]) {
          dinam[l][r] += dinam[l][m] * dinam[m][r];
          dinam[l][r] %= ((long long)1e9 + 7);
        }
      }
    }
  }
  cout << dinam[0][n - 1];
}
