#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double EPS = 1e-8;
inline double dot(const complex<double> &a, const complex<double> &b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
inline double cross(const complex<double> &a, const complex<double> &b) {
  return a.real() * b.imag() - b.real() * a.imag();
}
int ccw(const complex<double> &a, complex<double> b, complex<double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > EPS) {
    return +1;
  } else if (cross(b, c) < -EPS) {
    return -1;
  } else if (dot(b, c) < -EPS) {
    return +2;
  } else if (dot(b, b) + EPS < dot(c, c)) {
    return -2;
  } else {
    return 0;
  }
}
struct segment {
  complex<double> a, b;
  segment() {}
  segment(const complex<double> &x, const complex<double> &y) : a(x), b(y) {}
  inline bool intersects(const segment &seg) const {
    return ccw(a, b, seg.a) * ccw(a, b, seg.b) <= 0 &&
           ccw(seg.a, seg.b, a) * ccw(seg.a, seg.b, b) <= 0;
  }
};
inline double area(const complex<double> &a, const complex<double> &b,
                   const complex<double> &c) {
  return abs(cross(b - a, c - a) / 2);
}
bool in_polygon(const vector<int> &polygon,
                const vector<complex<double> > &vert,
                const complex<double> &p) {
  const int N = polygon.size();
  segment seg(p, complex<double>(2e7, p.imag() + 0.1));
  int cnt = 0;
  for (int i = 0; i < N; ++i) {
    const int ni = (i + 1) % N;
    segment edge(vert[polygon[i]], vert[polygon[ni]]);
    if (seg.intersects(edge)) ++cnt;
    if (ccw(edge.a, p, edge.b) == -2) return true;
  }
  return cnt % 2 == 1;
}
bool visible(const vector<int> &polygon, int a, int b,
             const vector<complex<double> > &vert) {
  const int N = polygon.size();
  if (abs(a - b) == 1 || abs(a - b) == N - 1) return true;
  segment seg(vert[polygon[a]], vert[polygon[b]]);
  const complex<double> v = seg.b - seg.a;
  if (!in_polygon(polygon, vert, seg.a + v / abs(v) * 0.1) ||
      !in_polygon(polygon, vert, seg.b - v / abs(v) * 0.1))
    return false;
  for (int i = 0; i < N; ++i) {
    const int nv = (i + 1) % N;
    if (i == a || i == b) continue;
    if (nv == a || nv == b) {
    } else {
      segment edge(vert[polygon[i]], vert[polygon[nv]]);
      if (seg.intersects(edge)) return false;
    }
    const int ccw_val = ccw(seg.a, vert[polygon[i]], seg.b);
    if (ccw_val == -2) {
      return false;
    }
  }
  return true;
}
int vis_memo[210][210];
bool visible_memo(int a, int b) { return vis_memo[a][b]; }
ostream &operator<<(ostream &os, const vector<int> &v) {
  for (int val : v) {
    os << val << ' ';
  }
  return os;
}
long long memo[210][210];
long long calc(int a, int b) {
  const int N = b - a + 1;
  long long &res = memo[a][b];
  if (res != -1) {
    return res;
  }
  if (N == 3 || N == 2) return res = 1;
  if (N < 3) return res = 0;
  res = 0;
  for (int i = a + 1; i < b; ++i) {
    if (visible_memo(a, i) && visible_memo(b, i)) {
      res += calc(a, i) * calc(i, b);
      res %= MOD;
    }
  }
  return res;
}
bool solve() {
  int N;
  if (!(cin >> N)) return false;
  vector<complex<double> > vert;
  vector<int> polygon;
  for (int i = 0; i < N; ++i) {
    int x, y;
    cin >> x >> y;
    vert.push_back(complex<double>(x, y));
    polygon.push_back(i);
  }
  fill_n((long long *)memo, sizeof(memo) / sizeof(long long), -1);
  fill_n((int *)vis_memo, sizeof(vis_memo) / sizeof(int), -1);
  for (int i = 0; i < N; ++i) {
    for (int j = i + 1; j < N; ++j) {
      vis_memo[j][i] = vis_memo[i][j] = visible(polygon, i, j, vert);
    }
  }
  cout << calc(0, N - 1) << endl;
  return true;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  while (solve())
    ;
  return 0;
}
