#include <bits/stdc++.h>
using namespace std;
namespace FastIO {
const unsigned BUFFER_SIZE = 1 << 12;
class InputReader {
 protected:
  char buffer[BUFFER_SIZE];
  FILE* file = nullptr;
  size_t ptr = 0;
  size_t len = 0;
  bool isEnd = false;

 public:
  inline bool end() { return isEnd; }
  static inline bool isDigit(char c) { return c >= '0' && c <= '9'; }
  static inline bool isSpace(char c) {
    return (unsigned char)(c - '\t') < 5 || c == ' ';
  }
  static inline bool isNotSpace(char c) { return !isSpace(c); }
  static inline bool isUpper(char c) { return (unsigned char)(c - 'A') < 26; }
  static inline bool isLower(char c) { return (unsigned char)(c - 'a') < 26; }
  static inline bool isAlpha(char c) { return isUpper(c) || isLower(c); }
  static inline bool isNotEndl(char c) { return c != '\n'; }
  InputReader() {}
  InputReader(FILE* _file) : file(_file) {}
  inline bool readChar(char& dest) {
    if (__builtin_expect(ptr == len, false)) {
      len = fread((void*)buffer, 1, BUFFER_SIZE, file);
      ptr = 0;
    }
    if (__builtin_expect(ptr == len, false)) {
      dest = '\0';
      isEnd = true;
      return false;
    }
    dest = buffer[ptr++];
    return true;
  }
  template <class F>
  inline char skipCharacters(F check) {
    char c;
    do {
      if (__builtin_expect(!readChar(c), false)) return '\0';
    } while (!check(c));
    return c;
  }
  template <class T>
  inline int readUInteger(T& dest) {
    T value = 0;
    int length = 0;
    char start = skipCharacters(isDigit);
    if (__builtin_expect(start == '\0', false)) return 0;
    while (isDigit(start)) {
      ++length;
      start -= '0';
      value = value * 10 + start;
      readChar(start);
    }
    ptr--;
    dest = value;
    return length;
  }
  template <class T>
  inline int readInteger(T& dest) {
    char start = skipCharacters([](char c) { return isDigit(c) || c == '-'; });
    bool neg = start == '-';
    if (neg) readChar(start);
    ptr--;
    int flag = readUInteger(dest);
    if (neg) dest = -dest;
    return flag;
  }
  template <class T>
  inline bool readFloat(T& dest) {
    char start = skipCharacters([](char c) { return isDigit(c) || c == '-'; });
    bool neg = start == '-';
    if (neg) readChar(start);
    ptr--;
    unsigned long long p;
    if (!readUInteger(p)) return false;
    dest = static_cast<T>(p);
    char c;
    readChar(c);
    if (c == '.') {
      unsigned long long q;
      int l;
      l = readUInteger(q);
      if (l > 0) {
        unsigned long long pw = 1;
        while (l) {
          pw *= 10;
          --l;
        }
        dest += static_cast<T>(q) / pw;
      }
    } else
      --ptr;
    if (neg) dest = -dest;
    return true;
  }
  template <class F>
  inline int readString(string& dest, F check) {
    dest.clear();
    char c = skipCharacters(check);
    int l = 0;
    while (check(c)) {
      dest += c;
      ++l;
      if (__builtin_expect(!readChar(c), false)) break;
    }
    --ptr;
    return l;
  }
  inline int readString(string& dest) { return readString(dest, isNotSpace); }
  template <class F>
  inline int readCString(char* dest, F check) {
    char c = skipCharacters(check);
    int l = 0;
    while (check(c)) {
      *dest = c;
      ++dest;
      ++l;
      if (__builtin_expect(!readChar(c), false)) break;
    }
    --ptr;
    *dest = '\0';
    return l;
  }
  inline int readCString(char* dest) { return readCString(dest, isNotSpace); }
};
class OutputWriter {
 protected:
  char buffer[BUFFER_SIZE];
  char tmp[BUFFER_SIZE];
  FILE* file;
  size_t len = 0;
  int tptr = 0;
  unsigned long long basePw = 1;
  int prec = 0;
  template <class T>
  inline void processUInteger(T what) {
    tptr = 0;
    while (what > 0) {
      tmp[tptr++] = what % 10;
      what /= 10;
    }
  }

 public:
  OutputWriter() : file(nullptr) {}
  OutputWriter(FILE* _file) : file(_file) {}
  inline void flush() {
    fwrite((void*)buffer, 1, len, file);
    len = 0;
  }
  ~OutputWriter() { flush(); }
  inline void checkFlush(size_t space = 0) {
    if (__builtin_expect(len + space >= BUFFER_SIZE, false)) flush();
  }
  inline void precision(int val) {
    basePw = 1;
    prec = 0;
    while (val > 0) {
      basePw *= 10;
      --val;
      ++prec;
    }
  }
  inline void writeChar(char c) {
    checkFlush(1);
    buffer[len++] = c;
  }
  template <class T>
  inline void writeUInteger(T what) {
    if (what == 0) {
      writeChar('0');
      return;
    }
    processUInteger(what);
    checkFlush(tptr);
    for (int i = tptr - 1; i >= 0; i--) buffer[len++] = tmp[i] + '0';
  }
  template <class T>
  inline void writeUInteger(T what, char delim) {
    writeUInteger(what);
    writeChar(delim);
  }
  template <class T>
  inline void writeInteger(T what) {
    if (what < 0) {
      writeChar('-');
      what = -what;
    }
    writeUInteger(what);
  }
  template <class T>
  inline void writeInteger(T what, char delim) {
    writeInteger(what);
    writeChar(delim);
  }
  inline void writeString(const string& s) {
    for (char c : s) writeChar(c);
  }
  inline void writeString(const string& s, char delim) {
    writeString(s);
    writeChar(delim);
  }
  inline void writeCString(const char* s) {
    while (*s != '\0') writeChar(*(s++));
  }
  inline void writeCString(const char* s, char delim) {
    writeCString(s);
    writeChar(delim);
  }
  template <class T>
  inline void writeFloat(T what) {
    bool neg = signbit(what);
    if (neg) {
      what = -what;
      writeChar('-');
    }
    if (isnan(what)) {
      writeChar('N');
      writeChar('a');
      writeChar('N');
      return;
    }
    if (isinf(what)) {
      writeChar('I');
      writeChar('n');
      writeChar('f');
      return;
    }
    auto p = static_cast<unsigned long long>(what);
    auto q = static_cast<unsigned long long>((what - p) * basePw + T(0.5));
    if (q >= basePw) {
      ++p;
      q = 0;
    }
    writeUInteger(p);
    if (prec == 0) return;
    writeChar('.');
    processUInteger(q);
    for (int i = tptr; i < prec; i++) writeChar('0');
    checkFlush(tptr);
    for (int i = tptr - 1; i >= 0; i--) buffer[len++] = tmp[i] + '0';
  }
  template <class T>
  inline void writeFloat(T what, char delim) {
    writeFloat(what);
    writeChar(delim);
  }
};
}  // namespace FastIO
struct pt {
  long long x, y;
  pt() {}
  pt(long long _x, long long _y) : x(_x), y(_y) {}
  pt operator+(const pt& a) const { return pt(x + a.x, y + a.y); }
  pt operator-(const pt& a) const { return pt(x - a.x, y - a.y); }
  bool operator<(const pt& a) const {
    return make_pair(x, y) < make_pair(a.x, a.y);
  }
  bool operator==(const pt& a) const { return x == a.x && y == a.y; }
  bool operator!=(const pt& a) const { return !(*this == a); }
};
const int maxn = 2e5 + 5;
int n, k;
pt p[maxn];
set<pt> ans;
void slow() {
  set<pt> has;
  for (int i = (0); i < (n); i++) has.insert(p[i]);
  for (int i = (0); i < (n); i++) {
    for (int j = (i); j < (n); j++) {
      pt curr = p[i] + p[j];
      int failed = 0;
      for (int c = (0); c < (n); c++) {
        pt sym = curr - p[c];
        if (!has.count(sym)) ++failed;
      }
      if (failed <= k) ans.insert(curr);
    }
  }
}
void solve() {
  for (int lp = (0); lp < (k + 1); lp++) {
    for (int rp = (n - k - 1); rp < (n); rp++) {
      pt curr = p[lp] + p[rp];
      int failed = 0;
      int ptr = n - 1;
      for (int i = (0); i < (n); i++) {
        pt sym = curr - p[i];
        while (ptr >= 0 && sym < p[ptr]) --ptr;
        if (ptr < 0 || p[ptr] != sym) ++failed;
      }
      if (failed <= k) ans.insert(curr);
    }
  }
}
signed main() {
  FastIO::InputReader in(stdin);
  FastIO::OutputWriter out(stdout);
  in.readInteger(n);
  in.readInteger(k);
  for (int i = (0); i < (n); i++) {
    in.readInteger(p[i].x);
    in.readInteger(p[i].y);
  }
  sort(p, p + n);
  if (k >= n) {
    out.writeInteger(-1);
    out.flush();
    return 0;
  }
  if (2 * k + 2 >= n)
    slow();
  else
    solve();
  out.precision(8);
  out.writeInteger(ans.size(), '\n');
  for (auto curr : (ans)) {
    long double x = curr.x / 2.0;
    long double y = curr.y / 2.0;
    out.writeFloat(x, ' ');
    out.writeFloat(y, '\n');
  }
  out.flush();
  return 0;
}

### Prompt

Develop a solution in CPP to the problem described below:

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;
namespace FastIO {
const unsigned BUFFER_SIZE = 1 << 12;
class InputReader {
 protected:
  char buffer[BUFFER_SIZE];
  FILE* file = nullptr;
  size_t ptr = 0;
  size_t len = 0;
  bool isEnd = false;

 public:
  inline bool end() { return isEnd; }
  static inline bool isDigit(char c) { return c >= '0' && c <= '9'; }
  static inline bool isSpace(char c) {
    return (unsigned char)(c - '\t') < 5 || c == ' ';
  }
  static inline bool isNotSpace(char c) { return !isSpace(c); }
  static inline bool isUpper(char c) { return (unsigned char)(c - 'A') < 26; }
  static inline bool isLower(char c) { return (unsigned char)(c - 'a') < 26; }
  static inline bool isAlpha(char c) { return isUpper(c) || isLower(c); }
  static inline bool isNotEndl(char c) { return c != '\n'; }
  InputReader() {}
  InputReader(FILE* _file) : file(_file) {}
  inline bool readChar(char& dest) {
    if (__builtin_expect(ptr == len, false)) {
      len = fread((void*)buffer, 1, BUFFER_SIZE, file);
      ptr = 0;
    }
    if (__builtin_expect(ptr == len, false)) {
      dest = '\0';
      isEnd = true;
      return false;
    }
    dest = buffer[ptr++];
    return true;
  }
  template <class F>
  inline char skipCharacters(F check) {
    char c;
    do {
      if (__builtin_expect(!readChar(c), false)) return '\0';
    } while (!check(c));
    return c;
  }
  template <class T>
  inline int readUInteger(T& dest) {
    T value = 0;
    int length = 0;
    char start = skipCharacters(isDigit);
    if (__builtin_expect(start == '\0', false)) return 0;
    while (isDigit(start)) {
      ++length;
      start -= '0';
      value = value * 10 + start;
      readChar(start);
    }
    ptr--;
    dest = value;
    return length;
  }
  template <class T>
  inline int readInteger(T& dest) {
    char start = skipCharacters([](char c) { return isDigit(c) || c == '-'; });
    bool neg = start == '-';
    if (neg) readChar(start);
    ptr--;
    int flag = readUInteger(dest);
    if (neg) dest = -dest;
    return flag;
  }
  template <class T>
  inline bool readFloat(T& dest) {
    char start = skipCharacters([](char c) { return isDigit(c) || c == '-'; });
    bool neg = start == '-';
    if (neg) readChar(start);
    ptr--;
    unsigned long long p;
    if (!readUInteger(p)) return false;
    dest = static_cast<T>(p);
    char c;
    readChar(c);
    if (c == '.') {
      unsigned long long q;
      int l;
      l = readUInteger(q);
      if (l > 0) {
        unsigned long long pw = 1;
        while (l) {
          pw *= 10;
          --l;
        }
        dest += static_cast<T>(q) / pw;
      }
    } else
      --ptr;
    if (neg) dest = -dest;
    return true;
  }
  template <class F>
  inline int readString(string& dest, F check) {
    dest.clear();
    char c = skipCharacters(check);
    int l = 0;
    while (check(c)) {
      dest += c;
      ++l;
      if (__builtin_expect(!readChar(c), false)) break;
    }
    --ptr;
    return l;
  }
  inline int readString(string& dest) { return readString(dest, isNotSpace); }
  template <class F>
  inline int readCString(char* dest, F check) {
    char c = skipCharacters(check);
    int l = 0;
    while (check(c)) {
      *dest = c;
      ++dest;
      ++l;
      if (__builtin_expect(!readChar(c), false)) break;
    }
    --ptr;
    *dest = '\0';
    return l;
  }
  inline int readCString(char* dest) { return readCString(dest, isNotSpace); }
};
class OutputWriter {
 protected:
  char buffer[BUFFER_SIZE];
  char tmp[BUFFER_SIZE];
  FILE* file;
  size_t len = 0;
  int tptr = 0;
  unsigned long long basePw = 1;
  int prec = 0;
  template <class T>
  inline void processUInteger(T what) {
    tptr = 0;
    while (what > 0) {
      tmp[tptr++] = what % 10;
      what /= 10;
    }
  }

 public:
  OutputWriter() : file(nullptr) {}
  OutputWriter(FILE* _file) : file(_file) {}
  inline void flush() {
    fwrite((void*)buffer, 1, len, file);
    len = 0;
  }
  ~OutputWriter() { flush(); }
  inline void checkFlush(size_t space = 0) {
    if (__builtin_expect(len + space >= BUFFER_SIZE, false)) flush();
  }
  inline void precision(int val) {
    basePw = 1;
    prec = 0;
    while (val > 0) {
      basePw *= 10;
      --val;
      ++prec;
    }
  }
  inline void writeChar(char c) {
    checkFlush(1);
    buffer[len++] = c;
  }
  template <class T>
  inline void writeUInteger(T what) {
    if (what == 0) {
      writeChar('0');
      return;
    }
    processUInteger(what);
    checkFlush(tptr);
    for (int i = tptr - 1; i >= 0; i--) buffer[len++] = tmp[i] + '0';
  }
  template <class T>
  inline void writeUInteger(T what, char delim) {
    writeUInteger(what);
    writeChar(delim);
  }
  template <class T>
  inline void writeInteger(T what) {
    if (what < 0) {
      writeChar('-');
      what = -what;
    }
    writeUInteger(what);
  }
  template <class T>
  inline void writeInteger(T what, char delim) {
    writeInteger(what);
    writeChar(delim);
  }
  inline void writeString(const string& s) {
    for (char c : s) writeChar(c);
  }
  inline void writeString(const string& s, char delim) {
    writeString(s);
    writeChar(delim);
  }
  inline void writeCString(const char* s) {
    while (*s != '\0') writeChar(*(s++));
  }
  inline void writeCString(const char* s, char delim) {
    writeCString(s);
    writeChar(delim);
  }
  template <class T>
  inline void writeFloat(T what) {
    bool neg = signbit(what);
    if (neg) {
      what = -what;
      writeChar('-');
    }
    if (isnan(what)) {
      writeChar('N');
      writeChar('a');
      writeChar('N');
      return;
    }
    if (isinf(what)) {
      writeChar('I');
      writeChar('n');
      writeChar('f');
      return;
    }
    auto p = static_cast<unsigned long long>(what);
    auto q = static_cast<unsigned long long>((what - p) * basePw + T(0.5));
    if (q >= basePw) {
      ++p;
      q = 0;
    }
    writeUInteger(p);
    if (prec == 0) return;
    writeChar('.');
    processUInteger(q);
    for (int i = tptr; i < prec; i++) writeChar('0');
    checkFlush(tptr);
    for (int i = tptr - 1; i >= 0; i--) buffer[len++] = tmp[i] + '0';
  }
  template <class T>
  inline void writeFloat(T what, char delim) {
    writeFloat(what);
    writeChar(delim);
  }
};
}  // namespace FastIO
struct pt {
  long long x, y;
  pt() {}
  pt(long long _x, long long _y) : x(_x), y(_y) {}
  pt operator+(const pt& a) const { return pt(x + a.x, y + a.y); }
  pt operator-(const pt& a) const { return pt(x - a.x, y - a.y); }
  bool operator<(const pt& a) const {
    return make_pair(x, y) < make_pair(a.x, a.y);
  }
  bool operator==(const pt& a) const { return x == a.x && y == a.y; }
  bool operator!=(const pt& a) const { return !(*this == a); }
};
const int maxn = 2e5 + 5;
int n, k;
pt p[maxn];
set<pt> ans;
void slow() {
  set<pt> has;
  for (int i = (0); i < (n); i++) has.insert(p[i]);
  for (int i = (0); i < (n); i++) {
    for (int j = (i); j < (n); j++) {
      pt curr = p[i] + p[j];
      int failed = 0;
      for (int c = (0); c < (n); c++) {
        pt sym = curr - p[c];
        if (!has.count(sym)) ++failed;
      }
      if (failed <= k) ans.insert(curr);
    }
  }
}
void solve() {
  for (int lp = (0); lp < (k + 1); lp++) {
    for (int rp = (n - k - 1); rp < (n); rp++) {
      pt curr = p[lp] + p[rp];
      int failed = 0;
      int ptr = n - 1;
      for (int i = (0); i < (n); i++) {
        pt sym = curr - p[i];
        while (ptr >= 0 && sym < p[ptr]) --ptr;
        if (ptr < 0 || p[ptr] != sym) ++failed;
      }
      if (failed <= k) ans.insert(curr);
    }
  }
}
signed main() {
  FastIO::InputReader in(stdin);
  FastIO::OutputWriter out(stdout);
  in.readInteger(n);
  in.readInteger(k);
  for (int i = (0); i < (n); i++) {
    in.readInteger(p[i].x);
    in.readInteger(p[i].y);
  }
  sort(p, p + n);
  if (k >= n) {
    out.writeInteger(-1);
    out.flush();
    return 0;
  }
  if (2 * k + 2 >= n)
    slow();
  else
    solve();
  out.precision(8);
  out.writeInteger(ans.size(), '\n');
  for (auto curr : (ans)) {
    long double x = curr.x / 2.0;
    long double y = curr.y / 2.0;
    out.writeFloat(x, ' ');
    out.writeFloat(y, '\n');
  }
  out.flush();
  return 0;
}

```