#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double EPS = 1e-8, INF = 1e12, PI = acos(-1.0);
namespace std {
bool operator<(const complex<double>& a, const complex<double>& b) {
  return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}  // namespace std
inline double cross(const complex<double>& a, const complex<double>& b) {
  return imag(conj(a) * b);
}
inline double dot(const complex<double>& a, const complex<double>& b) {
  return real(conj(a) * b);
}
struct L : public vector<complex<double> > {
  L(const complex<double>& a, const complex<double>& b) {
    push_back(a);
    push_back(b);
  }
};
inline int ccw(complex<double> a, complex<double> b, complex<double> c) {
  b -= a;
  c -= a;
  if (cross(b, c) > 0) return +1;
  if (cross(b, c) < 0) return -1;
  if (dot(b, c) < 0) return +2;
  if (norm(b) < norm(c)) return -2;
  return 0;
}
inline bool intersectSS(const L& s, const L& t) {
  return ccw(s[0], s[1], t[0]) * ccw(s[0], s[1], t[1]) == -1 &&
         ccw(t[0], t[1], s[0]) * ccw(t[0], t[1], s[1]) == -1;
}
inline bool intersectSSs(const L& s, const L& t) {
  if (ccw(t[0], s[0], s[1]) == 2 || ccw(t[1], s[0], s[1]) == 2) return 1;
  if (intersectSS(s, t)) return 1;
  return 0;
}
enum { OUT, ON, IN };
inline int contains(const vector<complex<double> >& po,
                    const complex<double>& p) {
  bool in = false;
  for (int i = 0; i < po.size(); ++i) {
    complex<double> a = po[i] - p, b = po[(i + 1) % po.size()] - p;
    if (imag(a) > imag(b)) swap(a, b);
    if (imag(a) <= 0 && 0 < imag(b))
      if (cross(a, b) < 0) in = !in;
    if (cross(a, b) == 0 && dot(a, b) <= 0) return ON;
  }
  return in ? IN : OUT;
}
const int mod = inf + 7;
int n, x[200], y[200];
bool can[210][210];
int dp[210][210];
int rec(int l, int r) {
  int& res = dp[l][r];
  if (res >= 0) return res;
  if (r - l <= 2) return res = 1;
  res = 0;
  for (int i = l + 1; i < r; i++)
    if (can[l][i] && can[i][r])
      (res += rec(l, i) * (long long)rec(i, r) % mod) %= mod;
  return res;
}
int main() {
  memset(dp, -1, sizeof(dp));
  cin >> n;
  vector<complex<double> > g;
  for (int i = 0; i < (int)n; i++)
    cin >> x[i] >> y[i], g.push_back(complex<double>(x[i], y[i]));
  for (int i = 0; i < (int)n; i++)
    for (int j = 0; j < (int)i; j++)
      if (abs(i - j) > 1) {
        const double r = 0.5;
        complex<double> p = g[i] * r + g[j] * (1 - r);
        if (contains(g, p) != IN) continue;
        bool ok = 1;
        L l(g[i], g[j]);
        for (int k = 0; k < (int)n; k++) {
          if (intersectSSs(l, L(g[k], g[(k + 1) % n]))) {
            ok = 0;
            break;
          }
        }
        can[i][j] = can[j][i] = ok;
      }
  for (int i = 0; i < (int)n; i++)
    can[i][(i + 1) % n] = can[(i + 1) % n][i] = 1;
  cout << rec(0, n - 1) << endl;
  return 0;
}
