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.io.PrintStream;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.ArrayList;

//851C - Five Dimensional Points

public class fdp {
    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();
            TaskC.Point a[] = new TaskC.Point[n];
            for (int i = 0; i < n; i++)
                a[i] = new TaskC.Point(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt());

            if (n >= 100) {
                System.out.println(0);
                return;
            }
            int ans = 0;
            ArrayList<Integer> ansPoints = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                TaskC.Point curr = a[i];
                TreeSet<TaskC.Point> vects = new TreeSet<>();
                for (int j = 0; j < n; j++) {
                    if (i != j) {
                        vects.add(vect(curr, a[j]));
                    }
                }
                boolean check = true;
                for (TaskC.Point v1 : vects) {
                    for (TaskC.Point v2 : vects) {
                        if (v1.compareTo(v2) != 0) {
                            if (angle(v1, v2) < 90) {
                                check = false;
                            }
                        }
                    }
                }
                if (check) {
                    ans++;
                    ansPoints.add(i + 1);
                }
            }
            out.println(ans);
            for (int i = 0; i < ansPoints.size(); i++)
                out.println(ansPoints.get(i));
        }

        static TaskC.Point vect(TaskC.Point a, TaskC.Point b) {
            return new TaskC.Point(b.x1 - a.x1, b.x2 - a.x2, b.x3 - a.x3, b.x4 - a.x4, b.x5 - a.x5);
        }

        static int dot(TaskC.Point a, TaskC.Point b) {
            return a.x1 * b.x1 + a.x2 * b.x2 + a.x3 * b.x3 + a.x4 * b.x4 + a.x5 * b.x5;
        }

        static double angle(TaskC.Point a, TaskC.Point b) {
            double num = dot(a, b);
            double dom = mag(a) * mag(b);
            if (dom == 0)
                return 91;
            double angle = Math.toDegrees(Math.acos(num / dom));

            if (angle > 180)
                return angle - 180;
            return angle;
        }

        static double mag(TaskC.Point a) {
            return Math.sqrt(a.x1 * a.x1 + a.x2 * a.x2 + a.x3 * a.x3 + a.x4 * a.x4 + a.x5 * a.x5);
        }

        static class Point implements Comparable<TaskC.Point> {
            Integer x1;
            Integer x2;
            Integer x3;
            Integer x4;
            Integer x5;

            public Point(int x1, int x2, int x3, int x4, int x5) {
                this.x1 = x1;
                this.x2 = x2;
                this.x3 = x3;
                this.x4 = x4;
                this.x5 = x5;
            }


            public int compareTo(TaskC.Point point) {
                if (x1 == point.x1) {
                    if (x2 == point.x2) {
                        if (x3 == point.x3) {
                            if (x4 == point.x4) {
                                if (x5 == point.x5) {
                                    return 0;
                                }
                                return x5.compareTo(point.x5);
                            }
                            return x4.compareTo(point.x4);
                        }
                        return x3.compareTo(point.x3);
                    }
                    return x2.compareTo(point.x2);
                }
                return x1.compareTo(point.x1);
            }

            public String toString() {
                return "[ " + x1 + " " + x2 + " " + x3 + " " + x4 + " " + x5 + " ]";
            }

        }

    }
}