#include <bits/stdc++.h>
template <typename _Tp>
void read(_Tp &x) {
  char ch(getchar());
  bool f(false);
  while (!isdigit(ch)) f |= ch == 45, ch = getchar();
  x = ch & 15, ch = getchar();
  while (isdigit(ch)) x = x * 10 + (ch & 15), ch = getchar();
  if (f) x = -x;
}
template <typename _Tp, typename... Args>
void read(_Tp &t, Args &...args) {
  read(t);
  read(args...);
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
  a = a < b ? b : a;
}
const int N = 205;
int n, k;
int x[N], y[N], dp[N][N];
long long a[N][N], all;
inline int nxt(int x) { return x + 1 == n ? 0 : x + 1; }
inline int pre(int x) { return !x ? n - 1 : x - 1; }
inline long long cross(long long x1, long long y1, long long x2, long long y2) {
  return x1 * y2 - x2 * y1;
}
bool check(long long mid) {
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j) dp[i][j] = 0;
  for (int len = 3; len <= n; ++len) {
    int i = 0, j = len - 1;
    do {
      if (a[i][j] < mid) {
        i = nxt(i), j = nxt(j);
        continue;
      }
      dp[i][j] = 1;
      for (int k = nxt(i), p = i; k != j; k = nxt(k)) {
        while (a[k][p] - a[j][i] < mid) p = nxt(p);
        chmax(dp[i][j], dp[p][k] + 1);
      }
      for (int k = nxt(i), p = k; k != j; k = nxt(k)) {
        while (p < j && a[p][k] - a[j][i] - a[p][j] - a[i][k] < mid) p = nxt(p);
        if (a[p][k] - a[j][i] - a[p][j] - a[i][k] < mid) break;
        chmax(dp[i][j], dp[p][j] + dp[i][k] + 1);
      }
      i = nxt(i), j = nxt(j);
    } while (i);
  }
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j)
      if (dp[i][j] + dp[j][i] >= k + 1) return true;
  return false;
}
int main() {
  read(n, k);
  for (int i = 0; i < n; ++i) read(x[i], y[i]);
  for (int i = 0; i < n; ++i) {
    int j = nxt(i), k;
    long long s = 0;
    for (; j != i; j = k)
      a[i][j] = s, k = nxt(j),
      s += cross(x[j] - x[i], y[j] - y[i], x[k] - x[i], y[k] - y[i]);
  }
  all = a[0][n - 1];
  for (int i = 0; i < n; ++i) a[i][i] = all;
  long long l = 0, r = 1e18, mid;
  while (l < r) mid = (l + r + 1) >> 1, check(mid) ? l = mid : r = mid - 1;
  printf("%lld\n", l);
  return 0;
}

### Prompt

Your challenge is to write a cpp solution to the following problem:

You are given a strictly convex polygon with n vertices.

You will make k cuts that meet the following conditions: 

  * each cut is a segment that connects two different nonadjacent vertices; 
  * two cuts can intersect only at vertices of the polygon. 



Your task is to maximize the area of the smallest region that will be formed by the polygon and those k cuts.

Input

The first line contains two integers n, k (3 ≤ n ≤ 200, 0 ≤ k ≤ n-3).

The following n lines describe vertices of the polygon in anticlockwise direction. The i-th line contains two integers x_i, y_i (|x_i|, |y_i| ≤ 10^8) — the coordinates of the i-th vertex.

It is guaranteed that the polygon is convex and that no two adjacent sides are parallel.

Output

Print one integer: the maximum possible area of the smallest region after making k cuts multiplied by 2.

Examples

Input


8 4
-2 -4
2 -2
4 2
1 5
0 5
-4 4
-5 0
-5 -1


Output


11


Input


6 3
2 -2
2 -1
1 2
0 2
-2 1
-1 0


Output


3

Note

In the first example, it's optimal to make cuts between the following pairs of vertices: 

  * (-2, -4) and (4, 2), 
  * (-2, -4) and (1, 5), 
  * (-5, -1) and (1, 5), 
  * (-5, 0) and (0, 5). 

<image> Points (-5, -1), (1, 5), (0, 5), (-5, 0) determine the smallest region with double area of 11. 

In the second example, it's optimal to make cuts between the following pairs of vertices: 

  * (2, -1) and (0, 2), 
  * (2, -1) and (1, 0), 
  * (-1, 0) and (0, 2). 

<image> Points (2, -2), (2, -1), (-1, 0) determine one of the smallest regions with double area of 3. 

### Response

```cpp
#include <bits/stdc++.h>
template <typename _Tp>
void read(_Tp &x) {
  char ch(getchar());
  bool f(false);
  while (!isdigit(ch)) f |= ch == 45, ch = getchar();
  x = ch & 15, ch = getchar();
  while (isdigit(ch)) x = x * 10 + (ch & 15), ch = getchar();
  if (f) x = -x;
}
template <typename _Tp, typename... Args>
void read(_Tp &t, Args &...args) {
  read(t);
  read(args...);
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
  a = a < b ? b : a;
}
const int N = 205;
int n, k;
int x[N], y[N], dp[N][N];
long long a[N][N], all;
inline int nxt(int x) { return x + 1 == n ? 0 : x + 1; }
inline int pre(int x) { return !x ? n - 1 : x - 1; }
inline long long cross(long long x1, long long y1, long long x2, long long y2) {
  return x1 * y2 - x2 * y1;
}
bool check(long long mid) {
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j) dp[i][j] = 0;
  for (int len = 3; len <= n; ++len) {
    int i = 0, j = len - 1;
    do {
      if (a[i][j] < mid) {
        i = nxt(i), j = nxt(j);
        continue;
      }
      dp[i][j] = 1;
      for (int k = nxt(i), p = i; k != j; k = nxt(k)) {
        while (a[k][p] - a[j][i] < mid) p = nxt(p);
        chmax(dp[i][j], dp[p][k] + 1);
      }
      for (int k = nxt(i), p = k; k != j; k = nxt(k)) {
        while (p < j && a[p][k] - a[j][i] - a[p][j] - a[i][k] < mid) p = nxt(p);
        if (a[p][k] - a[j][i] - a[p][j] - a[i][k] < mid) break;
        chmax(dp[i][j], dp[p][j] + dp[i][k] + 1);
      }
      i = nxt(i), j = nxt(j);
    } while (i);
  }
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j)
      if (dp[i][j] + dp[j][i] >= k + 1) return true;
  return false;
}
int main() {
  read(n, k);
  for (int i = 0; i < n; ++i) read(x[i], y[i]);
  for (int i = 0; i < n; ++i) {
    int j = nxt(i), k;
    long long s = 0;
    for (; j != i; j = k)
      a[i][j] = s, k = nxt(j),
      s += cross(x[j] - x[i], y[j] - y[i], x[k] - x[i], y[k] - y[i]);
  }
  all = a[0][n - 1];
  for (int i = 0; i < n; ++i) a[i][i] = all;
  long long l = 0, r = 1e18, mid;
  while (l < r) mid = (l + r + 1) >> 1, check(mid) ? l = mid : r = mid - 1;
  printf("%lld\n", l);
  return 0;
}

```