#include <bits/stdc++.h>
using namespace std;
void maxify(int &a, int b) { b > a && (a = b); }
void minify(int &a, int b) { b < a && (a = b); }
struct IOManager {
  template <typename T>
  inline bool read(T &x) {
    char c;
    bool flag = false;
    x = 0;
    while (~c && !isdigit(c = getchar()) && c != '-')
      ;
    c == '-' && (flag = true, c = getchar());
    if (!~c) return false;
    while (isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
    return (flag && (x = -x), true);
  }
  inline bool read(char &c) {
    c = '\n';
    while (~c && !(isprint(c = getchar()) && c != ' '))
      ;
    return ~c;
  }
  inline int read(char s[]) {
    char c;
    int len = 0;
    while (~c && !(isprint(c = getchar()) && c != ' '))
      ;
    if (!~c) return 0;
    while (isprint(c) && c != ' ') s[len++] = c, c = getchar();
    return (s[len] = '\0', len);
  }
  template <typename T>
  inline IOManager operator>(T &x) {
    read(x);
    return *this;
  }
  template <typename T>
  inline void write(T x) {
    x < 0 && (putchar('-'), x = -x);
    x > 9 && (write(x / 10), true);
    putchar(x % 10 + '0');
  }
  inline void write(char c) { putchar(c); }
  inline void write(char s[]) {
    int pos = 0;
    while (s[pos] != '\0') putchar(s[pos++]);
  }
  template <typename T>
  inline IOManager operator<(T x) {
    write(x);
    return *this;
  }
} io;
struct Point {
  int a, b, c, d, e;
  Point(int _a = 0, int _b = 0, int _c = 0, int _d = 0, int _e = 0)
      : a(_a), b(_b), c(_c), d(_d), e(_e) {}
  Point operator-(const Point &x) const {
    return Point(a - x.a, b - x.b, c - x.c, d - x.d, e - x.e);
  }
  int operator*(const Point &x) const {
    return a * x.a + b * x.b + c * x.c + d * x.d + e * x.e;
  }
};
static const double EPS = 1e-8;
static const double PI = acos(-1.0);
int cmp(double t) { return fabs(t) < EPS ? 0 : t > 0 ? 1 : -1; }
struct Solver {
 private:
  static const int N = 1000;
  int n;
  bool vis[N + 1];
  Point point[N + 1];
  void input() {
    io > n;
    for (int i = 1; i <= n; ++i)
      io > point[i].a > point[i].b > point[i].c > point[i].d > point[i].e;
  }
  void process() {
    for (int i = 1; i <= n; ++i)
      for (int j = 1; j <= n; ++j) {
        if (j == i) continue;
        for (int k = 1; k <= n; ++k) {
          if (k == i || k == j) continue;
          Point a = point[j] - point[i];
          Point b = point[k] - point[i];
          double angel = acos(a * b / (sqrt(a * a) * sqrt(b * b)));
          if (cmp(angel - PI / 2) == -1) vis[i] = true;
          if (vis[i]) break;
        }
        if (vis[i]) break;
      }
    int ans = 0;
    for (int i = 1; i <= n; ++i) ans += !vis[i];
    io < ans < '\n';
    for (int i = 1; i <= n; ++i)
      if (!vis[i]) io < i < '\n';
  }

 public:
  void solve() { input(), process(); }
} solver;
int main() {
  solver.solve();
  return 0;
}

### Prompt

Develop a solution in cpp to the problem described below:

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;
void maxify(int &a, int b) { b > a && (a = b); }
void minify(int &a, int b) { b < a && (a = b); }
struct IOManager {
  template <typename T>
  inline bool read(T &x) {
    char c;
    bool flag = false;
    x = 0;
    while (~c && !isdigit(c = getchar()) && c != '-')
      ;
    c == '-' && (flag = true, c = getchar());
    if (!~c) return false;
    while (isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
    return (flag && (x = -x), true);
  }
  inline bool read(char &c) {
    c = '\n';
    while (~c && !(isprint(c = getchar()) && c != ' '))
      ;
    return ~c;
  }
  inline int read(char s[]) {
    char c;
    int len = 0;
    while (~c && !(isprint(c = getchar()) && c != ' '))
      ;
    if (!~c) return 0;
    while (isprint(c) && c != ' ') s[len++] = c, c = getchar();
    return (s[len] = '\0', len);
  }
  template <typename T>
  inline IOManager operator>(T &x) {
    read(x);
    return *this;
  }
  template <typename T>
  inline void write(T x) {
    x < 0 && (putchar('-'), x = -x);
    x > 9 && (write(x / 10), true);
    putchar(x % 10 + '0');
  }
  inline void write(char c) { putchar(c); }
  inline void write(char s[]) {
    int pos = 0;
    while (s[pos] != '\0') putchar(s[pos++]);
  }
  template <typename T>
  inline IOManager operator<(T x) {
    write(x);
    return *this;
  }
} io;
struct Point {
  int a, b, c, d, e;
  Point(int _a = 0, int _b = 0, int _c = 0, int _d = 0, int _e = 0)
      : a(_a), b(_b), c(_c), d(_d), e(_e) {}
  Point operator-(const Point &x) const {
    return Point(a - x.a, b - x.b, c - x.c, d - x.d, e - x.e);
  }
  int operator*(const Point &x) const {
    return a * x.a + b * x.b + c * x.c + d * x.d + e * x.e;
  }
};
static const double EPS = 1e-8;
static const double PI = acos(-1.0);
int cmp(double t) { return fabs(t) < EPS ? 0 : t > 0 ? 1 : -1; }
struct Solver {
 private:
  static const int N = 1000;
  int n;
  bool vis[N + 1];
  Point point[N + 1];
  void input() {
    io > n;
    for (int i = 1; i <= n; ++i)
      io > point[i].a > point[i].b > point[i].c > point[i].d > point[i].e;
  }
  void process() {
    for (int i = 1; i <= n; ++i)
      for (int j = 1; j <= n; ++j) {
        if (j == i) continue;
        for (int k = 1; k <= n; ++k) {
          if (k == i || k == j) continue;
          Point a = point[j] - point[i];
          Point b = point[k] - point[i];
          double angel = acos(a * b / (sqrt(a * a) * sqrt(b * b)));
          if (cmp(angel - PI / 2) == -1) vis[i] = true;
          if (vis[i]) break;
        }
        if (vis[i]) break;
      }
    int ans = 0;
    for (int i = 1; i <= n; ++i) ans += !vis[i];
    io < ans < '\n';
    for (int i = 1; i <= n; ++i)
      if (!vis[i]) io < i < '\n';
  }

 public:
  void solve() { input(), process(); }
} solver;
int main() {
  solver.solve();
  return 0;
}

```