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;

public class C {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));		
		
		int n = Integer.parseInt(br.readLine());
		Point5[] points = new Point5[n];
		
		for(int i=0; i<n; i++) {
			String[] l = br.readLine().split(" ");
			points[i] = new Point5(l);
		}
		
		boolean[] bad = new boolean[n];
		int count = 0;
		
		for(int i=0; i<n; i++) {
			for(int j=0; j<n && !bad[i]; j++) {
				for(int k=0; k<n && !bad[i]; k++) {
					if(i != j && j != k && i != k) {
						if(VectorHelper.isBad(points[i], points[j], points[k])) {
							bad[i] = true;
							count++;
						}
					}
				}					
			}
		}
		
		System.out.println(n-count);
		for(int i=0; i<n; i++) {
			if(!bad[i]) {
				System.out.println(i+1);
			}
		}
	}

}

class Point5 {
	int[] v;	
	public Point5(String[] l){
		v = new int[5];
		for(int i=0; i<5; i++) {
			v[i] = Integer.parseInt(l[i]);
		}
	}
}

class VectorHelper {	
	private static double magnitude(int[] x) {
		double m = 0;
		for(int i=0; i<5; i++) {
			m += x[i]*x[i];
		}
		return Math.sqrt(m);
	}
	
	private static double angle(int[] ab, int[] ac) {
		double theta = 0;
		for(int i=0; i<5; i++) {
			theta += ab[i]*ac[i];
		}
		theta = theta / (magnitude(ab)*magnitude(ac));
		return Math.acos(theta);
	}
	
	public static boolean isBad(Point5 a, Point5 b, Point5 c) {
		int[] ab = new int[5];
		int[] ac = new int[5];
		
		for(int i=0; i<5; i++) {
			ab[i] = b.v[i] - a.v[i];
			ac[i] = c.v[i] - a.v[i];
		}
		
		double angle = angle(ab, ac);
		return angle < (Math.PI/2);		
	}
}
