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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class FiveDPoints {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// store input into points array
		int n = Integer.parseInt(br.readLine());
		boolean[] good = new boolean[n];
		Arrays.fill(good, true);
		int[][] points = new int[n][5];
		for (int i = 0; i < n; i++) {
			String[] input = br.readLine().split(" ");
			for (int j = 0; j < 5; j++) {
				points[i][j] = Integer.parseInt(input[j]);
			}
		}
		// compare each point to find it's angle
		int count = n;
		for (int i = 0; i < points.length; i++) {
			for (int j = i + 1; j < points.length; j++) {
				for (int k = j + 1; k < points.length; k++) {
					if (good[j] && acute(j, i, k, points)) {
						good[j] = false;
						count--;
					}
					if (good[k] && acute(k, j, i, points)) {
						good[k] = false;
						count--;
					}
					if (good[i] && acute(i, j, k, points)) {
						good[i] = false;
						count--;
					}
				}
			}

		}
		StringBuilder s = new StringBuilder();
		s.append(count + "\n");
		for (int i = 0; i < good.length; i++) {
			if (good[i]) {
				s.append((1 + i) + "\n");
			}
		}
		System.out.print(s);
	}

	/**
	 * tests if 2 points are acute
	 **/
	public static boolean acute(int i, int j, int k, int[][] points) {
		int dot = 0;
		int[] iToj = new int[5];
		int[] iTok = new int[5];
		for (int l = 0; l < 5; l++) {
			iToj[l] = points[j][l] - points[i][l];
			iTok[l] = points[k][l] - points[i][l];
		}
		for (int p = 0; p < iToj.length; p++) {
			dot += iToj[p] * iTok[p];
		}
		return dot > 0;
	}
}
