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 double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = 1e200;
inline int sgn(double x) { return x < -eps ? -1 : x > eps; }
inline double sqr(double x) { return x * x; }
inline double a2r(double a) { return a * pi / 180; }
inline double r2a(double r) { return r / pi * 180; }
struct P {
  double x, y;
  P(double x = 0, double y = 0) : x(x), y(y){};
  friend bool operator==(const P& p1, const P& p2) {
    return sgn(p1.x - p2.x) == 0 && sgn(p1.y - p2.y) == 0;
  }
  friend bool operator<(const P& p1, const P& p2) {
    return sgn(p1.x - p2.x) == 0 ? sgn(p1.y - p2.y) < 0 : sgn(p1.x - p2.x) < 0;
  }
  friend bool operator>(const P& p1, const P& p2) {
    return sgn(p1.x - p2.x) == 0 ? sgn(p1.y - p2.y) > 0 : sgn(p1.x - p2.x) > 0;
  }
  friend P operator+(const P& p1, const P& p2) {
    return P(p1.x + p2.x, p1.y + p2.y);
  }
  friend P operator-(const P& p1, const P& p2) {
    return P(p1.x - p2.x, p1.y - p2.y);
  }
  friend P operator*(const P& p, double a) { return P(p.x * a, p.y * a); }
  friend P operator/(const P& p, double a) { return P(p.x / a, p.y / a); }
  friend inline double operator^(const P& p1, const P& p2) {
    return p1.x * p2.x + p1.y * p2.y;
  }
  friend inline double operator*(const P& p1, const P& p2) {
    return p1.x * p2.y - p1.y * p2.x;
  }
  friend inline double dot(const P& o, const P& a, const P& b) {
    return (a - o) ^ (b - o);
  }
  friend inline double cross(const P& o, const P& a, const P& b) {
    return (a - o) * (b - o);
  }
  friend double dist(const P& p1, const P& p2) {
    return sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
  }
  friend double dist2(const P& p1, const P& p2) {
    return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
  }
  double len() const { return sqrt(x * x + y * y); }
  double len2() const { return x * x + y * y; }
  double angle() const {
    double t = atan2(y, x);
    return sgn(t) >= 0 ? t : t + 2 * pi;
  }
  P trunc(double l) const {
    l /= len();
    return P(x * l, y * l);
  }
  P turn_left() const { return P(-y, x); }
  P turn_right() const { return P(y, -x); }
  P rotate(double th, const P& p) const {
    double c = cos(th), s = sin(th);
    return P(c * (x - p.x) - s * (y - p.y) + p.x,
             s * (x - p.x) + c * (y - p.y) + p.y);
  }
  bool in() { return scanf("%lf %lf", &x, &y) == 2; }
  void out() const { printf("%lf %lf\n", x, y); }
};
struct line {
  P a, b;
  line() {}
  line(P a, P b) : a(a), b(b) {}
  friend double dist(const P& p, const line& l) {
    return fabs(cross(p, l.a, l.b)) / dist(l.a, l.b);
  }
  friend int intersection(const line& l1, const line& l2, P& p) {
    if (l1.a == l1.b || l2.a == l2.b) return -1;
    double c1 = (l1.b - l1.a) * (l2.b - l2.a),
           c2 = (l2.a - l1.a) * (l2.b - l2.a);
    if (sgn(c1) == 0) {
      if (sgn(c2) == 0) {
        return 2;
      } else {
        return 0;
      }
    } else {
      p = l1.a + (l1.b - l1.a) * (c2 / c1);
      return 1;
    }
  }
  friend bool sameside(const P& p1, const P& p2, const line& l) {
    return sgn(cross(p1, l.a, l.b) * cross(p2, l.a, l.b)) > 0;
  }
  friend bool onseg(const P& p, const line& s) {
    if (sgn(cross(p, s.a, s.b)) == 0)
      if (sgn(p.x - min(s.a.x, s.b.x)) >= 0 &&
          sgn(p.x - max(s.a.x, s.b.x)) <= 0)
        if (sgn(p.y - min(s.a.y, s.b.y)) >= 0 &&
            sgn(p.y - max(s.a.y, s.b.y)) <= 0)
          return 1;
    return 0;
  }
  friend bool onseg2(const P& p, const line& s) {
    if (sgn(cross(p, s.a, s.b)) == 0)
      if (sgn(p.x - min(s.a.x, s.b.x)) >= 0 &&
          sgn(p.x - max(s.a.x, s.b.x)) <= 0)
        if (sgn(p.y - min(s.a.y, s.b.y)) >= 0 &&
            sgn(p.y - max(s.a.y, s.b.y)) <= 0)
          return !(p == s.a || p == s.b);
    return 0;
  }
  void in() { a.in(), b.in(); }
};
const int MAXN = 222;
const int MOD = 1000000007;
P p[MAXN];
bool ok[MAXN][MAXN];
int mem[MAXN][MAXN];
int ccw;
double area(vector<int> v) {
  double S = 0;
  for (int i = 0; i < v.size(); i++) S += p[v[i]] * p[v[(i + 1) % v.size()]];
  return (S / 2);
}
int dfs(int l, int r) {
  if (l + 1 == r) return 1;
  if (mem[l][r] != -1) return mem[l][r];
  int& ans = mem[l][r];
  ans = 0;
  for (int i = l + 1; i < r; i++) {
    double triArea = (cross(p[l], p[i], p[r]) / 2);
    if (sgn(triArea) > 0) {
      ans = (ans + (long long)dfs(l, i) * dfs(i, r) % MOD) % MOD;
    }
  }
  return ans;
}
int work(vector<int> v) {
  if (v.size() < 3) return 1;
  if (!ok[v[0]][v[1]]) return 0;
  int ans = 0;
  double allArea = area(v);
  for (int i = 2; i < v.size(); i++) {
    if (!ok[v[0]][v[i]]) continue;
    if (!ok[v[1]][v[i]]) continue;
    double triArea = (cross(p[v[0]], p[v[1]], p[v[i]]) / 2);
    if (sgn(triArea) <= 0) continue;
    if (v.size() == 3) {
      return 1;
    }
    vector<int> l;
    vector<int> r;
    for (int j = 1; j <= i; j++) {
      r.push_back(v[j]);
    }
    for (int j = i; j < v.size(); j++) {
      l.push_back(v[j]);
    }
    l.push_back(v[0]);
    double lArea = area(l);
    double rArea = area(r);
    p[v[0]].out();
    p[v[1]].out();
    p[v[i]].out();
    printf("@@%lf %lf %lf %lf\n", lArea, rArea, triArea, allArea);
    if (sgn(lArea + rArea + triArea - allArea) != 0) continue;
    int lAns = work(l);
    int rAns = work(r);
    ans = (ans + ((long long)lAns * rAns % MOD)) % MOD;
  }
  return ans;
}
int main() {
  int n;
  while (scanf("%d", &n) != EOF) {
    for (int i = 0; i < n; i++) {
      p[i].in();
    }
    double S = 0;
    for (int i = 0; i < n; i++) {
      S += p[i] * p[(i + 1) % n] / 2;
    }
    if (S < 0) {
      reverse(p, p + n);
    }
    for (int i = 0; i < n; i++) {
      for (int j = i; j < n; j++) {
        ok[i][j] = ok[j][i] = true;
        if (i == j) continue;
        line l1 = line(p[i], p[j]);
        for (int k = 0; k < n; k++) {
          if (i == k && j == k + 1) continue;
          line l2 = line(p[k], p[(k + 1) % n]);
          P inter;
          int res = intersection(l1, l2, inter);
          if (res == 1 && onseg2(inter, l2) && onseg2(inter, l1)) {
            ok[i][j] = ok[j][i] = false;
            break;
          }
        }
      }
    }
    vector<int> v;
    for (int i = 0; i < n; i++) {
      v.push_back(i);
    }
    memset(mem, -1, sizeof(mem));
    printf("%d\n", dfs(0, n - 1));
  }
}
