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.util.*;
import java.awt.Point;
import java.io.*;

public class C{
	public static void main(String[] args) {
		FastScannerC sc = new FastScannerC(System.in);
		
		int N = sc.nextInt();
		
		ArrayList<Point5> list = new ArrayList<>();
		
		for(int i = 0 ; i < N ; i++){
			int a = sc.nextInt();
			int b = sc.nextInt();
			int c = sc.nextInt();
			int d = sc.nextInt();
			int e = sc.nextInt();
			list.add(new Point5(a, b, c, d, e));
		}
		
		double[][] angles = new double[N][N];
		
		StringBuilder sb = new StringBuilder();
		ArrayList<Integer> indexes = new ArrayList<>();
		
		for(int i = 0 ; i < N ; i++){
			int ctr = 0;
			
			Point5 a = list.get(i);
			
			for(int k = 0 ; k < N ; k++){
				if(k == i)
					continue;
				
				
				Point5 b = list.get(k);
				
				for(int j = 0 ; j < N ; j++){
					
					if(j == k || j == i)
						continue;
					
					Point5 c = list.get(j);
					Point5 vecA = new Point5(b.a - a.a, b.b - a.b, b.c - a.c , b.d - a.d, b.e - a.e);
					Point5 vecB = new Point5(c.a - a.a, c.b - a.b, c.c - a.c , c.d - a.d, c.e - a.e);
				
					double ang = vecA.calculateAngle(vecB);
//					if(i == 0){
//						System.out.println(k + "  j=" + j + " ang = " + ang);
//					}
					if(ang < 90)
						ctr++;
					
					if(ctr > 1){
						break;
					}
				}
				if(ctr > 1)
					break;
			}
			if(ctr < 2){
				indexes.add((i+1));
			}
			
//			for(int j = i+1 ; j < N ; j++){
//				angles[i][j] = angles[j][i] = list.get(i).calculateAngle(list.get(j));
////				System.out.println("i = " + i + " j = " + j + " degrees = " + angles[i][j]);
//			}
////			int ctr = 0;
//			for(int j = 0 ; j < N ; j++){
//				if(i != j && angles[i][j] < 90){
//					ctr++;
//				}
//			}
//			if(ctr < 2){
//				indexes.add(i+1);
//			}
////			System.out.println();
		}
		
		sb.append(indexes.size()).append('\n');
		
		for(Integer it : indexes){
			sb.append(it).append(" ");
		}
		
		System.out.println(sb.toString());
	}
	
}

class Point5 {
	double a, b, c, d , e;
	
	Point5(double aa, double bb, double cc, double dd, double ee){
		a = aa;
		b = bb;
		c = cc;
		d = dd;
		e = ee;
	}

	public double calculateAngle(Point5 sec) {
		double res = vectorProduct(sec);
		double lenA = Math.sqrt(vectorProduct(this));
		double lenB = Math.sqrt(sec.vectorProduct(sec));
//		System.out.println(res + "  lenA " + lenA + "   lenB = " + lenB);
		
//		if(res != 0){
//			res = res/(lenA*lenB);
//		}
//		System.out.println("Res = " + res);
//		res = res/(lenA*lenB);
		
		double divBy = lenA * lenB;
		
//		System.out.println("Res = " + res + " DivBy = " + divBy);
		
//		if(res == 0 && divBy == 0)
//			res = 0;
//		else{
//			res = res / divBy;
//		}
		
		res = res / divBy;
		
		return Math.toDegrees(Math.acos(res));
	}
	
	public double vectorProduct(Point5 sec){
		double res = a*sec.a + b*sec.b + c*sec.c + d*sec.d + e*sec.e;
		return res;
	}
}

class FastScannerC{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastScannerC(InputStream stream)
    {
        this.stream = stream;
    }

    public int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars)
        {
            curChar = 0;
            try
            {
                numChars = stream.read(buf);
            } catch (IOException e)
            {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-')
        {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do
        {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String next()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }
    
    public String nextLine()
    {
        int c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isLineEndChar(c));
        return res.toString();
    }    
    
    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }
    
    public long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
    
    public boolean isSpaceChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }
    
    public boolean isLineEndChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == '\n' || c == '\r' || c == -1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}