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.*;
import java.util.*;
public class Main {

	public static void main(String[] args) {
		FastScanner sc=new FastScanner();
		PrintWriter pw=new PrintWriter(System.out);
		while(sc.hasNext()){
			int n=sc.nextInt();
			Point[]p=new Point[n];
			for(int o=0;o<n;o++){
				int a=sc.nextInt();
				int b=sc.nextInt();
				int c=sc.nextInt();
				int d=sc.nextInt();
				int e=sc.nextInt();
				p[o]=new Point(a,b,c,d,e,o+1);
			}
			TreeSet<Integer>set=new TreeSet<Integer>();
			for(int i=0;i<n;i++){
				boolean flag=true;
				for(int j=0;j<n&&flag;j++){
					if(j!=i)
					for(int k=0;k<n&&flag;k++){
						if(k!=j){
							Point t1=p[i].minus(p[j]);
							Point t2=p[i].minus(p[k]);
							double temp=js(t1,t2);
							//pw.println(i+" "+j+" "+k+" "+temp);
							if(temp>0){
								flag=false;
							}
						}
					}
				}
				if(flag)set.add(i+1);
			}
			pw.println(set.size());
			for(int k:set){
				pw.print(k+" ");
			}
			pw.flush();
		}

	}
	static double js(Point a,Point b){
		double sum=a.a*b.a+a.b*b.b+a.c*b.c+a.d*b.d+a.e*b.e;
		return sum;
	}
}
class Point{
	int a;
	int b;
	int c;
	int d;
	int e;
	int index;
	Point (int a,int b,int c,int d,int e,int index){
		this.a=a;
		this.b=b;
		this.c=c;
		this.d=d;
		this.e=e;
		this.index=index;
	}
	Point minus(Point p){
		return new Point(a-p.a,b-p.b,c-p.c,d-p.d,e-p.e,0);
	}
}
class FastScanner {
	BufferedReader br;
	StringTokenizer st;

	public FastScanner() {
		try {
			br = new BufferedReader(new InputStreamReader(System.in),32768);
			st = new StringTokenizer("");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public boolean hasNext() {
		while (!st.hasMoreTokens()) {
			String line = nextLine();
			if (line == null) {
				return false;
			}
			st = new StringTokenizer(line);
		}
		return true;
	}

	public String next() {
		while(!st.hasMoreTokens()){
			st=new StringTokenizer(nextLine());
		}
		return st.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

	public String nextLine() {
		String line = "";
		try {
			line = br.readLine();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return line;
	}
}