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 void ina(_T a[], int n) {
  for (int i = 0; i < n; i++) In(a[i]);
}
int TEST_CASE = 0;
template <class _T>
inline _T pow(_T a, _T b, _T m) {
  a %= m;
  _T ans = 1 % m;
  while (b) {
    if (b & 1) ans *= a, ans %= m;
    a *= a;
    a %= m;
    b >>= 1;
  }
  return ans;
}
template <class _T>
inline _T pow(_T a, _T b) {
  _T ans = 1;
  while (b) {
    if (b & 1) ans *= a;
    a *= a;
    b >>= 1;
  }
  return ans;
}
template <class _T>
inline _T add(_T a, _T b, _T m) {
  return a >= m - b ? a - (m - b) : a + b;
}
template <class _T>
inline _T multiply(_T a, _T b, _T m) {
  _T ans = 0;
  if (b > a) swap(a, b);
  while (b) {
    if (b & 1) ans = add(ans, a, m);
    b >>= 1;
    a = add(a, a, m);
  }
  return ans;
}
template <class _T>
inline _T bigpow(_T a, _T b, _T m) {
  a %= m;
  _T ans = 1 % m;
  while (b) {
    if (b & 1) ans = multiply(ans, a, m);
    a = multiply(a, a, m);
    b >>= 1;
  }
  return ans;
}
template <class _T>
inline _T modinvers(_T a, _T m) {
  return m > 2000000000LL ? bigpow(a, m - 2, m) : pow(a, m - 2, m);
}
template <class _T>
_T _egcd(_T a, _T b, _T &x, _T &y) {
  if (!b) {
    x = 1, y = 0;
    return a;
  }
  _T _g = _egcd(b, a % b, x, y);
  _T xt = x;
  x = y, y = xt - (a / b) * y;
  return _g;
}
template <class _T>
inline _T fmodinvers(_T a, _T m) {
  _T x, y;
  _egcd(a, m, x, y);
  x %= m;
  if (x < 0) x += m;
  return x;
}
template <class _T>
inline _T _lcm(_T a, _T b) {
  return (a * b) / __gcd(a, b);
}
template <class T>
inline T SQ(T a) {
  return a * a;
}
long long SQRT(long long n) {
  long long e = sqrt(n * 1.0);
  long long l = max(0LL, e - 2), r = min(n, e + 2);
  long long ans = 0;
  while (l <= r) {
    long long m = ((l + r) >> 1);
    if (m * m <= n)
      ans = m, l = m + 1;
    else
      r = m - 1;
  }
  return ans;
}
long long CBRT(long long n) {
  long long e = cbrt(n * 1.0);
  long long l = max(0LL, e - 2), r = min(n, e + 2);
  long long ans = 0;
  while (l <= r) {
    long long m = ((l + r) >> 1);
    if (m * m * m <= n)
      ans = m, l = m + 1;
    else
      r = m - 1;
  }
  return ans;
}
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
const int SIZE = 1e6;
long long mod = 1e9 + 7;
long long cross(pair<long long, long long> a, pair<long long, long long> b) {
  return ((long long)a.first) * b.second - ((long long)a.second) * b.first;
}
pair<long long, long long> operator-(pair<long long, long long> a,
                                     pair<long long, long long> b) {
  return {a.first - b.first, a.second - b.second};
}
bool col(pair<long long, long long> p0, pair<long long, long long> p1,
         pair<long long, long long> p2) {
  return cross(p1 - p0, p2 - p0) == 0;
}
bool ccw(pair<long long, long long> p0, pair<long long, long long> p1,
         pair<long long, long long> p2) {
  return cross(p1 - p0, p2 - p0) > 0;
}
bool cw(pair<long long, long long> p0, pair<long long, long long> p1,
        pair<long long, long long> p2) {
  return cross(p1 - p0, p2 - p0) < 0;
}
bool onSegment(pair<pair<long long, long long>, pair<long long, long long> > a,
               pair<long long, long long> b) {
  return b.first >= min(a.first.first, a.second.first) &&
         b.first <= max(a.first.first, a.second.first) &&
         b.second >= min(a.first.second, a.second.second) &&
         b.second <= max(a.first.second, a.second.second);
}
bool intersect(
    pair<pair<long long, long long>, pair<long long, long long> > a,
    pair<pair<long long, long long>, pair<long long, long long> > b) {
  long long d1 = cross(a.second - a.first, b.first - a.first);
  long long d2 = cross(a.second - a.first, b.second - a.first);
  long long d3 = cross(b.second - b.first, a.first - b.first);
  long long d4 = cross(b.second - b.first, a.second - b.first);
  if (((d1 > 0 && d2 < 0) || (d2 > 0 && d1 < 0)) &&
      ((d3 > 0 && d4 < 0) || (d4 > 0 && d3 < 0)))
    return 1;
  if (d1 == 0 && onSegment(a, b.first)) return 1;
  if (d2 == 0 && onSegment(a, b.second)) return 1;
  if (d3 == 0 && onSegment(b, a.first)) return 1;
  if (d4 == 0 && onSegment(b, a.second)) return 1;
  return 0;
}
long long R, RR;
bool check(vector<pair<long long, long long> > &p, int i, int j) {
  if (((i == 0 && j == ((int)(p).size()) - 1)) || i + 1 == j) return 1;
  for (int k = 0; k < ((int)(p).size()); k++) {
    if (k &&
        intersect(pair<pair<long long, long long>, pair<long long, long long> >(
                      p[i], p[j]),
                  pair<pair<long long, long long>, pair<long long, long long> >(
                      p[k - 1], p[k]))) {
      if (i == k || i == k - 1 || j == k || j == k - 1)
        ;
      else
        return 0;
    }
  }
  if (intersect(pair<pair<long long, long long>, pair<long long, long long> >(
                    p[i], p[j]),
                pair<pair<long long, long long>, pair<long long, long long> >(
                    p.back(), p[0]))) {
    if (i == 0 || j == 0 || i == ((int)(p).size()) - 1 ||
        j == ((int)(p).size()) - 1)
      ;
    else
      return 0;
  }
  long long area = p[j].first * p[i].second - p[j].second * p[i].first;
  for (int k = i; k < j; k++)
    area += (p[k].first * p[k + 1].second - p[k].second * p[k + 1].first);
  long long a2 = p[i].first * p[j].second - p[i].second * p[j].first;
  for (int k = j; k != i;) {
    int kk = (k + 1) % ((int)(p).size());
    a2 += p[k].first * p[kk].second - p[k].second * p[kk].first;
    k = kk;
  }
  return abs(R) == abs(a2) + abs(area);
}
vector<pair<long long, long long> > v;
long long mem[205][205];
long long dp(int l, int r) {
  if (l + 1 == r) return 1;
  long long &res = mem[l][r];
  if (~res) return res;
  res = 0;
  if (!check(v, l, r)) return res;
  for (int k = l + 1; k < r; k++)
    res += dp(l, k) * dp(k, r) * (!col(v[l], v[r], v[k])), res %= mod;
  return res;
}
int main() {
  int n;
  cin >> n;
  v.resize(n);
  for (int i = 0; i < n; i++) {
    cin >> v[i].first >> v[i].second;
  }
  R = v[0].first * v[n - 1].second - v[0].second * v[n - 1].first;
  for (int i = 0; i < n - 1; i++) {
    R += v[i + 1].first * v[i].second - v[i + 1].second * v[i].first;
  }
  RR = (R > 0 ? 1 : R < 0 ? -1 : 0);
  memset(mem, -1, sizeof(mem));
  cout << dp(0, n - 1) << '\n';
  return 0;
}
