#include <bits/stdc++.h>
using namespace std;
namespace baseFastio {
template <typename Int>
inline Int read() {
  Int flag = 1;
  char c = getchar();
  while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
  if (c == '-') flag = -1, c = getchar();
  Int init = c & 15;
  while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
  return init * flag;
}
template <typename Int>
inline Int read(char& c) {
  Int flag = 1;
  c = getchar();
  while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
  if (c == '-') flag = -1, c = getchar();
  Int init = c & 15;
  while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
  return init * flag;
}
template <typename Int>
inline void write(Int x) {
  if (x < 0) putchar('-'), x = ~x + 1;
  if (x > 9) write(x / 10);
  putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
  write(x);
  putchar(nextch);
}
}  // namespace baseFastio
namespace Fastio {
enum io_flags { ignore_int = 1 << 0 };
struct Reader {
  char endch;
  Reader() { endch = '\0'; }
  template <typename Int>
  Int operator()() {
    return baseFastio::read<Int>(endch);
    ;
  }
  Reader& operator>>(io_flags f) {
    if (f == ignore_int) baseFastio::read<int>();
    return *this;
  }
  template <typename Int>
  Reader& operator>>(Int& i) {
    i = baseFastio::read<Int>(endch);
    return *this;
  }
  template <typename Int>
  inline Int get_int() {
    return baseFastio::read<Int>();
  }
  inline char get_nxt() { return endch; }
} read;
struct Writer {
  Writer& operator<<(const char* ch) {
    while (*ch) putchar(*(ch++));
    return *this;
  }
  Writer& operator<<(const char ch) {
    putchar(ch);
    return *this;
  }
  template <typename Int>
  Writer& operator<<(const Int i) {
    baseFastio::write(i);
    return *this;
  }
} write;
}  // namespace Fastio
using namespace Fastio;
const int eps = 1e-8;
namespace against_cpp11 {
const int N = 1e3 + 7;
int n;
struct point {
  int x[5];
  inline int sqr_length() {
    return x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3] + x[4] * x[4];
  }
  inline double length() {
    return sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3] +
                x[4] * x[4]);
  }
  point operator-(const point& b) const {
    return (point){x[0] - b.x[0], x[1] - b.x[1], x[2] - b.x[2], x[3] - b.x[3],
                   x[4] - b.x[4]};
  }
  int operator*(const point b) const {
    return x[0] * b.x[0] + x[1] * b.x[1] + x[2] * b.x[2] + x[3] * b.x[3] +
           x[4] * b.x[4];
  }
} a[N];
vector<int> answer;
signed main() {
  read >> n;
  for (int i = 1; i <= n; i++) {
    read >> a[i].x[0] >> a[i].x[1] >> a[i].x[2] >> a[i].x[3] >> a[i].x[4];
  }
  for (int i = 1; i <= n; i++) {
    bool fail = false;
    for (int j = 1; j <= n && !fail; j++)
      if (i != j)
        for (int k = 1; k <= n && !fail; k++)
          if (i != k && j != k)
            if (acos((a[j] - a[i]) * (a[k] - a[i]) /
                     ((a[j] - a[i]).length() * (a[k] - a[i]).length())) <
                1.57079632679489661923)
              fail = true;
    if (!fail) answer.push_back(i);
  }
  write << answer.size() << '\n';
  for (size_t i = 0; i < answer.size(); i++) write << answer[i] << '\n';
  return 0;
}
}  // namespace against_cpp11
signed main() { return against_cpp11::main(); }

### Prompt

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

You are given set of n points in 5-dimensional space. The points are labeled from 1 to n. No two points coincide.

We will call point a bad if there are different points b and c, not equal to a, from the given set such that angle between vectors <image> and <image> is acute (i.e. strictly less than <image>). Otherwise, the point is called good.

The angle between vectors <image> and <image> in 5-dimensional space is defined as <image>, where <image> is the scalar product and <image> is length of <image>.

Given the list of points, print the indices of the good points in ascending order.

Input

The first line of input contains a single integer n (1 ≤ n ≤ 103) — the number of points.

The next n lines of input contain five integers ai, bi, ci, di, ei (|ai|, |bi|, |ci|, |di|, |ei| ≤ 103) — the coordinates of the i-th point. All points are distinct.

Output

First, print a single integer k — the number of good points.

Then, print k integers, each on their own line — the indices of the good points in ascending order.

Examples

Input

6
0 0 0 0 0
1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1


Output

1
1


Input

3
0 0 1 2 0
0 0 9 2 0
0 0 5 9 0


Output

0

Note

In the first sample, the first point forms exactly a <image> angle with all other pairs of points, so it is good.

In the second sample, along the cd plane, we can see the points look as follows:

<image>

We can see that all angles here are acute, so no points are good.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
namespace baseFastio {
template <typename Int>
inline Int read() {
  Int flag = 1;
  char c = getchar();
  while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
  if (c == '-') flag = -1, c = getchar();
  Int init = c & 15;
  while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
  return init * flag;
}
template <typename Int>
inline Int read(char& c) {
  Int flag = 1;
  c = getchar();
  while ((!isdigit(c)) && c != '-' && c != EOF) c = getchar();
  if (c == '-') flag = -1, c = getchar();
  Int init = c & 15;
  while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
  return init * flag;
}
template <typename Int>
inline void write(Int x) {
  if (x < 0) putchar('-'), x = ~x + 1;
  if (x > 9) write(x / 10);
  putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch) {
  write(x);
  putchar(nextch);
}
}  // namespace baseFastio
namespace Fastio {
enum io_flags { ignore_int = 1 << 0 };
struct Reader {
  char endch;
  Reader() { endch = '\0'; }
  template <typename Int>
  Int operator()() {
    return baseFastio::read<Int>(endch);
    ;
  }
  Reader& operator>>(io_flags f) {
    if (f == ignore_int) baseFastio::read<int>();
    return *this;
  }
  template <typename Int>
  Reader& operator>>(Int& i) {
    i = baseFastio::read<Int>(endch);
    return *this;
  }
  template <typename Int>
  inline Int get_int() {
    return baseFastio::read<Int>();
  }
  inline char get_nxt() { return endch; }
} read;
struct Writer {
  Writer& operator<<(const char* ch) {
    while (*ch) putchar(*(ch++));
    return *this;
  }
  Writer& operator<<(const char ch) {
    putchar(ch);
    return *this;
  }
  template <typename Int>
  Writer& operator<<(const Int i) {
    baseFastio::write(i);
    return *this;
  }
} write;
}  // namespace Fastio
using namespace Fastio;
const int eps = 1e-8;
namespace against_cpp11 {
const int N = 1e3 + 7;
int n;
struct point {
  int x[5];
  inline int sqr_length() {
    return x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3] + x[4] * x[4];
  }
  inline double length() {
    return sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2] + x[3] * x[3] +
                x[4] * x[4]);
  }
  point operator-(const point& b) const {
    return (point){x[0] - b.x[0], x[1] - b.x[1], x[2] - b.x[2], x[3] - b.x[3],
                   x[4] - b.x[4]};
  }
  int operator*(const point b) const {
    return x[0] * b.x[0] + x[1] * b.x[1] + x[2] * b.x[2] + x[3] * b.x[3] +
           x[4] * b.x[4];
  }
} a[N];
vector<int> answer;
signed main() {
  read >> n;
  for (int i = 1; i <= n; i++) {
    read >> a[i].x[0] >> a[i].x[1] >> a[i].x[2] >> a[i].x[3] >> a[i].x[4];
  }
  for (int i = 1; i <= n; i++) {
    bool fail = false;
    for (int j = 1; j <= n && !fail; j++)
      if (i != j)
        for (int k = 1; k <= n && !fail; k++)
          if (i != k && j != k)
            if (acos((a[j] - a[i]) * (a[k] - a[i]) /
                     ((a[j] - a[i]).length() * (a[k] - a[i]).length())) <
                1.57079632679489661923)
              fail = true;
    if (!fail) answer.push_back(i);
  }
  write << answer.size() << '\n';
  for (size_t i = 0; i < answer.size(); i++) write << answer[i] << '\n';
  return 0;
}
}  // namespace against_cpp11
signed main() { return against_cpp11::main(); }

```