#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
const int M = 1e9 + 7;
const ll MLL = 1e18L + 9;
#pragma unused(M)
#pragma unused(MLL)
template <ostream& out = cout, class... T>
void prints(T&&...) {}
template <ostream& out = cout, class... T>
void printd(T&&...) {}
template <ostream& out = cout, class... T>
void printde(T&&...) {}
template <ostream& out = cout, class... T>
void printb(T&&...) {}
template <ostream& out = cout, class... T>
void printArr(T&&...) {}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  struct D5 {
    int a, b, c, d, e;
    D5 operator-(const D5& d5) const {
      D5 ret;
      ret = {a - d5.a, b - d5.b, c - d5.c, d - d5.d, e - d5.e};
      return ret;
    }
    double operator*(const D5& d5) const {
      return a * d5.a + b * d5.b + c * d5.c + d * d5.d + e * d5.e;
    }
  };
  vector<D5> vs(n);
  for (int i = 0; i < n; i++) {
    cin >> vs[i].a >> vs[i].b >> vs[i].c >> vs[i].d >> vs[i].e;
  }
  vector<int> anss;
  for (int i = 0; i < n; i++) {
    bool ok = true;
    D5& va = vs[i];
    for (int j = 0; j < n; j++) {
      if (j == i) {
        continue;
      }
      D5& vb = vs[j];
      D5 ab = vb - va;
      for (int k = 0; k < j; k++) {
        if (k == i) {
          continue;
        }
        D5& vc = vs[k];
        D5 ac = vc - va;
        double num = ab * ac;
        if (0 < num) {
          ok = false;
          break;
        }
      }
    }
    if (ok) {
      anss.push_back(i + 1);
    }
  }
  cout << anss.size() << '\n';
  for (int i : anss) {
    cout << i << '\n';
  }
  return 0;
}

### Prompt

Create a solution in CPP for 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;
using uint = unsigned int;
using ll = long long;
const int M = 1e9 + 7;
const ll MLL = 1e18L + 9;
#pragma unused(M)
#pragma unused(MLL)
template <ostream& out = cout, class... T>
void prints(T&&...) {}
template <ostream& out = cout, class... T>
void printd(T&&...) {}
template <ostream& out = cout, class... T>
void printde(T&&...) {}
template <ostream& out = cout, class... T>
void printb(T&&...) {}
template <ostream& out = cout, class... T>
void printArr(T&&...) {}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  struct D5 {
    int a, b, c, d, e;
    D5 operator-(const D5& d5) const {
      D5 ret;
      ret = {a - d5.a, b - d5.b, c - d5.c, d - d5.d, e - d5.e};
      return ret;
    }
    double operator*(const D5& d5) const {
      return a * d5.a + b * d5.b + c * d5.c + d * d5.d + e * d5.e;
    }
  };
  vector<D5> vs(n);
  for (int i = 0; i < n; i++) {
    cin >> vs[i].a >> vs[i].b >> vs[i].c >> vs[i].d >> vs[i].e;
  }
  vector<int> anss;
  for (int i = 0; i < n; i++) {
    bool ok = true;
    D5& va = vs[i];
    for (int j = 0; j < n; j++) {
      if (j == i) {
        continue;
      }
      D5& vb = vs[j];
      D5 ab = vb - va;
      for (int k = 0; k < j; k++) {
        if (k == i) {
          continue;
        }
        D5& vc = vs[k];
        D5 ac = vc - va;
        double num = ab * ac;
        if (0 < num) {
          ok = false;
          break;
        }
      }
    }
    if (ok) {
      anss.push_back(i + 1);
    }
  }
  cout << anss.size() << '\n';
  for (int i : anss) {
    cout << i << '\n';
  }
  return 0;
}

```