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
#include <bits/stdc++.h>
using namespace std;
inline int min(const int &x, const int &y) { return x < y ? x : y; }
inline long long min(const long long &x, const long long &y) {
  return x < y ? x : y;
}
inline double min(const double &x, const double &y) { return x < y ? x : y; }
inline int max(const int &x, const int &y) { return x > y ? x : y; }
inline long long max(const long long &x, const long long &y) {
  return x > y ? x : y;
}
inline double max(const double &x, const double &y) { return x > y ? x : y; }
template <class T>
inline void _updmin(T &x, const T &y) {
  if (x > y) x = y;
}
template <class T>
inline void _updmax(T &x, const T &y) {
  if (x < y) x = y;
}
template <class T>
inline T _lowbit(const T &x) {
  return (x ^ (x - 1)) & x;
}
template <class T>
inline int _bitsize(const T &x) {
  return (x == 0) ? 0 : (1 + _bitsize(x & (x - 1)));
}
const double _pi = acos(-1.0);
const double _eps = 1e-5;
template <class T>
inline T _sqr(const T &x) {
  return x * x;
}
template <class T>
inline T _gcd(const T &x, const T &y) {
  if (x < 0) return _gcd(-x, y);
  if (y < 0) return _gcd(x, -y);
  return (y == 0) ? x : _gcd(y, x % y);
}
template <class T>
inline T _lcm(const T &x, const T &y) {
  if (x < 0) return _lcm(-x, y);
  if (y < 0) return _lcm(x, -y);
  return x * (y / _gcd(x, y));
}
template <class T>
inline T _euc(const T &a, const T &b, T &x, T &y) {
  if (a < 0) {
    T d = _euc(-a, b, x, y);
    x = -x;
    return d;
  }
  if (b < 0) {
    T d = _euc(a, -b, x, y);
    y = -y;
    return d;
  }
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  } else {
    T d = _euc(b, a % b, x, y);
    T t = x;
    x = y;
    y = t - (a / b) * y;
    return d;
  }
}
template <class T>
inline vector<pair<T, int> > _fac(T n) {
  vector<pair<T, int> > ret;
  for (T i = 2; n > 1;) {
    if (n % i == 0) {
      int cnt = 0;
      for (; n % i == 0; cnt++, n /= i)
        ;
      ret.push_back(make_pair(i, cnt));
    }
    i++;
    if (i > n / i) i = n;
  }
  if (n > 1) ret.push_back(make_pair(n, 1));
  return ret;
}
template <class T>
inline int _prm(const T &x) {
  if (x <= 1) return 0;
  for (T i = 2; sqr(i) <= x; i++)
    if (x % i == 0) return 0;
  return 1;
}
template <class T>
inline T _phi(T x) {
  vector<pair<T, int> > f = _fac(x);
  T ret = x;
  for (int i = 0; i < ((int)(f.size())); i++)
    ret = ret / f[i].first * (f[i].first - 1);
  return ret;
}
template <class T>
inline T _inv(T a, T b) {
  T x, y;
  _euc(a, b, x, y);
  if (x == 0) x = 1;
  return x;
}
template <class T>
inline T _cmod(T x, T m) {
  return (x % m + m) % m;
}
template <class T>
inline T _amod(T x, T y, T m) {
  return x = ((x + y) % m + m) % m;
}
template <class T>
inline T _mmod(T x, T y, T m) {
  return (
      T)((((long long)x) * ((long long)y) % ((long long)m) + ((long long)m)) %
         ((long long)m));
}
template <class T>
inline T _pmod(T x, T y, T m) {
  if (y == 0)
    return 1 % m;
  else if ((y & 1) == 0) {
    T z = _pmod(x, y >> 1, m);
    return _mmod(z, z, m);
  } else
    return _mmod(_pmod(x, y ^ 1, m), x, m);
}
const int _MTRXSIZE = 40;
template <class T>
inline void _shwMTRX(int n, T A[_MTRXSIZE][_MTRXSIZE]) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) cout << A[i][j] << " ";
    cout << endl;
  }
}
template <class T>
inline void _stdMTRX(int n, T A[_MTRXSIZE][_MTRXSIZE]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
}
template <class T>
inline void _addMTRX(int n, T C[_MTRXSIZE][_MTRXSIZE],
                     T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = A[i][j] + B[i][j];
}
template <class T>
inline void _subMTRX(int n, T C[_MTRXSIZE][_MTRXSIZE],
                     T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = A[i][j] - B[i][j];
}
template <class T>
inline void _mulMTRX(int n, T C[_MTRXSIZE][_MTRXSIZE],
                     T _A[_MTRXSIZE][_MTRXSIZE], T _B[_MTRXSIZE][_MTRXSIZE]) {
  T A[_MTRXSIZE][_MTRXSIZE], B[_MTRXSIZE][_MTRXSIZE];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) {
      A[i][j] = _A[i][j];
      B[i][j] = _B[i][j];
      C[i][j] = 0;
    }
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++) C[i][j] += A[i][k] * B[k][j];
}
template <class T>
inline void _addModMTRX(int n, T m, T C[_MTRXSIZE][_MTRXSIZE],
                        T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = _cmod(A[i][j] + B[i][j], m);
}
template <class T>
inline void _subModMTRX(int n, T m, T C[_MTRXSIZE][_MTRXSIZE],
                        T A[_MTRXSIZE][_MTRXSIZE], T B[_MTRXSIZE][_MTRXSIZE]) {
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) C[i][j] = _cmod(A[i][j] - B[i][j], m);
}
template <class T>
inline void _mulModMTRX(int n, T m, T C[_MTRXSIZE][_MTRXSIZE],
                        T _A[_MTRXSIZE][_MTRXSIZE],
                        T _B[_MTRXSIZE][_MTRXSIZE]) {
  T A[_MTRXSIZE][_MTRXSIZE], B[_MTRXSIZE][_MTRXSIZE];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) {
      A[i][j] = _A[i][j];
      B[i][j] = _B[i][j];
      C[i][j] = 0;
    }
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      for (int k = 0; k < n; k++)
        C[i][j] = (C[i][j] + _mmod(A[i][k], B[k][j], m)) % m;
}
template <class T>
inline void _powModMTRX(int n, T y, T m, T C[_MTRXSIZE][_MTRXSIZE],
                        T X[_MTRXSIZE][_MTRXSIZE]) {
  T R[_MTRXSIZE][_MTRXSIZE];
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) R[i][j] = X[i][j];
  _stdMTRX(n, C);
  if (y > 0)
    for (T i = 1;; i <<= 1) {
      if (y & i) _mulModMTRX(n, m, C, C, R);
      _mulModMTRX(n, m, R, R, R);
      if (i > (y >> 1)) break;
    }
}
template <class T>
struct _frct {
  T a, b;
  _frct(T a = 0, T b = 1);
  string toString();
};
template <class T>
_frct<T>::_frct(T a, T b) {
  T d = _gcd(a, b);
  a /= d;
  b /= d;
  if (b < 0) a = -a, b = -b;
  this->a = a;
  this->b = b;
}
template <class T>
string _frct<T>::toString() {
  ostringstream tout;
  tout << a << "/" << b;
  return tout.str();
}
template <class T>
_frct<T> operator+(_frct<T> p, _frct<T> q) {
  return _frct<T>(p.a * q.b + q.a * p.b, p.b * q.b);
}
template <class T>
_frct<T> operator-(_frct<T> p, _frct<T> q) {
  return _frct<T>(p.a * q.b - q.a * p.b, p.b * q.b);
}
template <class T>
_frct<T> operator*(_frct<T> p, _frct<T> q) {
  return _frct<T>(p.a * q.a, p.b * q.b);
}
template <class T>
_frct<T> operator/(_frct<T> p, _frct<T> q) {
  return _frct<T>(p.a * q.b, p.b * q.a);
}
struct Point {
  int x, y;
  Point() { x = y = 0; }
  Point(const int &_x, const int &_y) {
    x = _x;
    y = _y;
  }
  bool operator<(const Point &pnt) const {
    return pnt.x != x ? pnt.x > x : pnt.y > y;
  }
  bool operator==(const Point &pnt) const { return pnt.x == x && pnt.y == y; }
  bool operator!=(const Point &pnt) const { return pnt.x != x || pnt.y != y; }
} a[210000];
int check(int l, int r, int m, const Point &core) {
  while (l <= r && m >= 0) {
    Point pnt = Point(core.x - a[l].x, core.y - a[l].y);
    while (r > l && pnt < a[r]) {
      r--;
      m--;
    }
    if (l == r) {
      if (a[l] != pnt) m--;
      break;
    }
    if (pnt == a[r]) {
      l++;
      r--;
    } else {
      l++;
      m--;
    }
  }
  return m >= 0 ? 1 : 0;
}
int n, m;
set<Point> s;
set<Point>::iterator it;
int main() {
  while (scanf("%d%d", &n, &m) != EOF) {
    for (int i = 0; i < n; i++) scanf("%d%d", &a[i].x, &a[i].y);
    if (m >= n) {
      printf("-1\n");
      continue;
    }
    sort(a, a + n);
    s.clear();
    for (int lef = 0; lef <= m; lef++) {
      for (int rig = 0; lef + rig <= m; rig++) {
        int mid = m - lef - rig;
        int l = lef, r = n - rig - 1;
        Point core = Point(a[l].x + a[r].x, a[l].y + a[r].y);
        if (check(l, r, mid, core)) {
          s.insert(core);
        }
      }
    }
    printf("%d\n", ((int)(s.size())));
    for (it = s.begin(); it != s.end(); it++)
      printf("%.2f %.2f\n", ((double)(*it).x) * 0.5, ((double)(*it).y) * 0.5);
  }
  return 0;
}
