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.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.ArrayList;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Yuan Lei
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            if (n > 40) {
                out.println(0);
                return;
            } else {
                final ArrayList<TaskC.Point> points = new ArrayList<>();
                for (int i = 0; i < n; ++i) {
                    int a, b, c, d, e;
                    a = in.nextInt();
                    b = in.nextInt();
                    c = in.nextInt();
                    d = in.nextInt();
                    e = in.nextInt();
                    points.add(new TaskC.Point(a, b, c, d, e));
                }
                if (n < 3) {
                    out.println(n);
                    for (int i = 1; i <= n; ++i) {
                        out.println(i);
                    }
                    return;
                }
                ArrayList<Integer> result = new ArrayList<>();
                for (int center = 0; center < n; ++center) {
                    boolean find = false;
                    for (int a = 0; a < n; ++a)
                        if (a != center) {
                            for (int b = 0; b < n; ++b)
                                if (b != center && b != a) {
                                    TaskC.Point A = points.get(a).minus(points.get(center));
                                    TaskC.Point B = points.get(b).minus(points.get(center));
                                    if (A.dot(B)) {
                                        find = true;
                                        break;
                                    }
                                }
                            if (find) break;
                        }
                    if (!find) result.add(center + 1);
                }
                out.println(result.size());
                for (int id : result) {
                    out.println(id);
                }
            }
        }

        static class Point {
            long a;
            long b;
            long c;
            long d;
            long e;

            public Point(long a, long b, long c, long d, long e) {
                this.a = a;
                this.b = b;
                this.c = c;
                this.d = d;
                this.e = e;
            }

            boolean dot(final TaskC.Point rhs) {
                return a * rhs.a + b * rhs.b + c * rhs.c + d * rhs.d + e * rhs.e > 0;
            }

            TaskC.Point minus(final TaskC.Point rhs) {
                return new TaskC.Point(a - rhs.a, b - rhs.b, c - rhs.c, d - rhs.d, e - rhs.e);
            }

        }

    }
}

