#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
struct pt {
  long double a, b, c, d, e;
  pt() {}
};
pt operator+(pt x, pt y) {
  pt z;
  z.a = x.a + y.a;
  z.b = x.b + y.b;
  z.c = x.c + y.c;
  z.d = x.d + y.d;
  z.e = x.e + y.e;
  return z;
}
pt operator-(pt x, pt y) {
  pt z;
  z.a = x.a - y.a;
  z.b = x.b - y.b;
  z.c = x.c - y.c;
  z.d = x.d - y.d;
  z.e = x.e - y.e;
  return z;
}
void imp(pt x) {
  cout << x.a << " " << x.b << " " << x.c << " " << x.d << " " << x.e << endl;
}
long double operator*(pt x, pt y) {
  return x.a * y.a + x.b * y.b + x.c * y.c + x.d * y.d + x.e * y.e;
}
long double val(pt x) { return sqrtl(x * x); }
pt A[1010];
vector<int> R;
int main() {
  int n;
  while (scanf("%d", &n) != EOF) {
    for (int i = 0; i < n; i++)
      cin >> A[i].a >> A[i].b >> A[i].c >> A[i].d >> A[i].e;
    if (n > 100) {
      printf("%d\n", 0);
      continue;
    }
    long double pd2 = pi / (long double)2.0;
    R.clear();
    for (int i = 0; i < n; i++) {
      pt puta = A[i];
      for (int j = 0; j < n; j++) {
        A[j] = (A[j] - puta);
      }
      bool sw = 1;
      for (int j = 0; j < n; j++) {
        if (j == i) continue;
        for (int k = j + 1; k < n; k++) {
          if (k == i) continue;
          if (acosl(A[j] * A[k] / (val(A[j]) * val(A[k]))) < pd2) sw = 0;
        }
      }
      for (int j = 0; j < n; j++) A[j] = (A[j] + puta);
      if (sw) R.push_back(i);
    }
    printf("%d\n", (int)R.size());
    for (int i = 0; i < (int)R.size(); i++) printf("%d\n", R[i] + 1);
  }
}

### Prompt

Construct a cpp code solution to the problem outlined:

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;
const long double pi = acos(-1);
struct pt {
  long double a, b, c, d, e;
  pt() {}
};
pt operator+(pt x, pt y) {
  pt z;
  z.a = x.a + y.a;
  z.b = x.b + y.b;
  z.c = x.c + y.c;
  z.d = x.d + y.d;
  z.e = x.e + y.e;
  return z;
}
pt operator-(pt x, pt y) {
  pt z;
  z.a = x.a - y.a;
  z.b = x.b - y.b;
  z.c = x.c - y.c;
  z.d = x.d - y.d;
  z.e = x.e - y.e;
  return z;
}
void imp(pt x) {
  cout << x.a << " " << x.b << " " << x.c << " " << x.d << " " << x.e << endl;
}
long double operator*(pt x, pt y) {
  return x.a * y.a + x.b * y.b + x.c * y.c + x.d * y.d + x.e * y.e;
}
long double val(pt x) { return sqrtl(x * x); }
pt A[1010];
vector<int> R;
int main() {
  int n;
  while (scanf("%d", &n) != EOF) {
    for (int i = 0; i < n; i++)
      cin >> A[i].a >> A[i].b >> A[i].c >> A[i].d >> A[i].e;
    if (n > 100) {
      printf("%d\n", 0);
      continue;
    }
    long double pd2 = pi / (long double)2.0;
    R.clear();
    for (int i = 0; i < n; i++) {
      pt puta = A[i];
      for (int j = 0; j < n; j++) {
        A[j] = (A[j] - puta);
      }
      bool sw = 1;
      for (int j = 0; j < n; j++) {
        if (j == i) continue;
        for (int k = j + 1; k < n; k++) {
          if (k == i) continue;
          if (acosl(A[j] * A[k] / (val(A[j]) * val(A[k]))) < pd2) sw = 0;
        }
      }
      for (int j = 0; j < n; j++) A[j] = (A[j] + puta);
      if (sw) R.push_back(i);
    }
    printf("%d\n", (int)R.size());
    for (int i = 0; i < (int)R.size(); i++) printf("%d\n", R[i] + 1);
  }
}

```