#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f, g, h, i, j, k;
struct Point {
  int x, y;
  Point() {}
  Point(int x, int y) : x(x), y(y) {}
  friend bool operator<(const Point &x, const Point &y) {
    return x.x < y.x || (x.x == y.x && x.y < y.y);
  }
  friend Point operator+(const Point &x, const Point &y) {
    return Point(x.x + y.x, x.y + y.y);
  }
  friend Point operator-(const Point &x, const Point &y) {
    return Point(x.x - y.x, x.y - y.y);
  }
};
Point G[200005], an[200005], M;
set<Point> GG, HH;
Point Mid(Point x, Point y) {
  return Point((x.x + y.x) >> 1, (x.y + y.y) >> 1);
}
Point Mirror(Point x, Point y) {
  Point kk = y - x;
  return y + kk;
}
int main() {
  scanf("%d%d", &a, &b);
  for (i = 1; i <= a; i++) {
    scanf("%d%d", &c, &d);
    G[i] = Point(c << 1, d << 1);
    GG.insert(G[i]);
  }
  sort(G + 1, G + a + 1);
  if (b >= a) {
    printf("-1\n");
    return 0;
  }
  c = 0;
  for (i = 1; i <= b + 1; i++)
    for (j = a; j >= a - b && j >= i; j--) {
      M = Mid(G[i], G[j]);
      if (HH.find(M) != HH.end()) continue;
      HH.insert(M);
      e = 0;
      for (k = i; k <= j; k++) {
        e += GG.find(Mirror(G[k], M)) == GG.end();
        if (e + i - 1 + a - j > b) break;
      }
      if (e + i - 1 + a - j <= b) {
        an[++c] = M;
      }
    }
  printf("%d\n", c);
  for (i = 1; i <= c; i++)
    printf("%.1lf %.1lf\n", (double)an[i].x / 2.0, (double)an[i].y / 2.0);
  return 0;
}

### Prompt

In Cpp, your task is to solve the following problem:

As Gerald ..., in other words, on a New Year Eve Constantine prepared an unusual present for the Beautiful Lady. The present is the magic New Year snowflake that can make any dream come true.

The New Year snowflake consists of tiny ice crystals, which can be approximately regarded as points on the plane. The beauty of the New Year snowflake is that it has a center of symmetry. This is a point such that for each crystal of the snowflake exists another crystal, symmetrical to it relative to that point. One of the crystals can be placed directly in the center of symmetry.

While Constantine was choosing a snowflake among millions of other snowflakes, no less symmetrical and no less magical, then endured a difficult path through the drifts to the house of his mistress, while he was waiting with bated breath for a few long moments before the Beautiful Lady opens the door, some of the snowflake crystals melted and naturally disappeared. Constantine is sure that there were no more than k of such crystals, because he handled the snowflake very carefully. Now he is ready to demonstrate to the Beautiful Lady all the power of nanotechnology and restore the symmetry of snowflakes.

You are given the coordinates of the surviving snowflake crystals, given in nanometers. Your task is to identify all possible positions of the original center of symmetry.

Input

The first line contains two integers n and k (1 ≤ n ≤ 200 000, 0 ≤ k ≤ 10) — the number of the surviving snowflake crystals and the maximum number of melted crystals, correspondingly. Next n lines contain the coordinates of the crystals that are left in the following form: "xi yi". The coordinates are integers and do not exceed 5·108 in absolute value. All given points are different.

Output

The first line contains an integer c — the number of possible symmetry centers. Next c lines should contain the centers' descriptions. Each symmetry center is described by a couple of coordinates "x y", separated by a space. Print the coordinates with absolute error not exceeding 10 - 6. You are allowed to print the symmetry centers in any order. All printed points should be different. If there exist an infinite number of possible symmetry centers, print the single number "-1".

Examples

Input

4 0
0 0
0 1
1 0
1 1


Output

1
0.5 0.5


Input

4 2
0 0
0 1
1 0
1 1


Output

5
0.0 0.5
0.5 0.0
0.5 0.5
0.5 1.0
1.0 0.5


Input

4 4
0 0
0 1
1 0
1 1


Output

-1

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f, g, h, i, j, k;
struct Point {
  int x, y;
  Point() {}
  Point(int x, int y) : x(x), y(y) {}
  friend bool operator<(const Point &x, const Point &y) {
    return x.x < y.x || (x.x == y.x && x.y < y.y);
  }
  friend Point operator+(const Point &x, const Point &y) {
    return Point(x.x + y.x, x.y + y.y);
  }
  friend Point operator-(const Point &x, const Point &y) {
    return Point(x.x - y.x, x.y - y.y);
  }
};
Point G[200005], an[200005], M;
set<Point> GG, HH;
Point Mid(Point x, Point y) {
  return Point((x.x + y.x) >> 1, (x.y + y.y) >> 1);
}
Point Mirror(Point x, Point y) {
  Point kk = y - x;
  return y + kk;
}
int main() {
  scanf("%d%d", &a, &b);
  for (i = 1; i <= a; i++) {
    scanf("%d%d", &c, &d);
    G[i] = Point(c << 1, d << 1);
    GG.insert(G[i]);
  }
  sort(G + 1, G + a + 1);
  if (b >= a) {
    printf("-1\n");
    return 0;
  }
  c = 0;
  for (i = 1; i <= b + 1; i++)
    for (j = a; j >= a - b && j >= i; j--) {
      M = Mid(G[i], G[j]);
      if (HH.find(M) != HH.end()) continue;
      HH.insert(M);
      e = 0;
      for (k = i; k <= j; k++) {
        e += GG.find(Mirror(G[k], M)) == GG.end();
        if (e + i - 1 + a - j > b) break;
      }
      if (e + i - 1 + a - j <= b) {
        an[++c] = M;
      }
    }
  printf("%d\n", c);
  for (i = 1; i <= c; i++)
    printf("%.1lf %.1lf\n", (double)an[i].x / 2.0, (double)an[i].y / 2.0);
  return 0;
}

```