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 c
{
	public static void main(String[] args)
	{
		FastScanner in = new FastScanner();
		int n = in.nextInt();
		if(n >= 150)
			System.out.println("0");
		else
		{
			Point points[] = new Point[n];
			
			for(int i = 0; i < n; i++)
				points[i] = new Point(in);
			
			ArrayList<Integer> ans = new ArrayList<>();
			int cnt = 0;
			for(int a = 0; a < n; a++)
			{
				boolean good = true;
				for(int b = 0; b < n; b++)
				{
					if(a == b) continue;
					for(int c = 0; c < n; c++)
					{
						if(c == a || c == b) continue;
						Vector ab = new Vector(points[a], points[b]);
						Vector ac = new Vector(points[a], points[c]);
						
						int dot = ab.dot(ac);
						double mag = ab.length() * ac.length();
						double angle = Math.acos(((double)dot)/mag);
						
						if(angle < Math.PI/2)
							good = false;
					}
				}
				
				if(good)
				{
					ans.add(a+1);
					cnt++;
				}
			}
			
			System.out.println(cnt);
			for(Integer i : ans)
				System.out.println(i);
		}
	}
	
	public static class Point
	{
		int x[];
		
		public Point(FastScanner in)
		{
			x = new int[5];
			for(int i = 0; i < x.length; i++)
				x[i] = in.nextInt();
		}
	}
	
	public static class Vector
	{
		int dx[];
		
		public Vector(Point a, Point b)
		{
			dx = new int[5];
			for(int i = 0; i < dx.length; i++)
				dx[i] = b.x[i] - a.x[i];
		}
		
		public double length()
		{
			int sum = 0;
			for(int i = 0; i < dx.length; i++)
				sum += dx[i]*dx[i];
			
			return Math.sqrt(sum);
		}
		
		public int dot(Vector o)
		{
			int sum = 0;
			
			for(int i = 0; i < dx.length; i++)
				sum += dx[i]*o.dx[i];
			
			return sum;
		}
	}
	
	public static class FastScanner
	{
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s)
		{
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public FastScanner()
		{
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String nextToken()
		{
			while (st == null || !st.hasMoreElements())
			{
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt()
		{
			return Integer.parseInt(nextToken());
		}

		long nextLong()
		{
			return Long.parseLong(nextToken());
		}

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