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.io.*;
/*
TASK: fivedimpoints
LANG: JAVA
 */

public class fivedimpoints{
    static int n;
    static int[][] coord;
    static long[][][] vect;
    static boolean[] bad;
    
    public static void main(String[] args) throws IOException{
        FastScanner in = new FastScanner(System.in); 
        n = in.nextInt();
        if(n > 11){
            System.out.println(0);
            return;
        }
        coord = new int[n][5];
        vect = new long[n][n][5];
        bad = new boolean[n];
        for(int i = 0;i <n; i++){
            for(int j = 0;j < 5;j++){
                coord[i][j] = in.nextInt();
            }
        }
        for(int i = 0;i < n; i++){
            for(int j = 0;j < n; j++){
                for(int k = 0; k < 5; k++){
                    vect[i][j][k] = coord[j][k] - coord[i][k];
                }
            }
        }
        int count = n;
        long prod;
        for(int i = 0;i < n; i++){
            for(int j = 0;j < n; j++){
                if(j != i){
                    for(int k = 0; k < n; k++){
                        if(k != j && k != i){
                            prod = 0;
                            for(int m = 0; m < 5; m++){
                                prod += vect[j][i][m]*vect[k][i][m];
                            }
                            if(prod > 0 && !bad[i]){
                                bad[i] = true;
                                count--;
                            }
                        }
                    }
                }
            }
        }
        System.out.println(count);
        for(int i = 0;i < n; i++){
            if(!bad[i]){
                System.out.println(i+1);
            }
        }
    }
}
class FastScanner{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public FastScanner(InputStream stream) {
        this.stream = stream;
    }
    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++];
    }

    boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    boolean isEndline(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

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

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

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

    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();
        while (isEndline(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndline(c));
        return res.toString();
    }
}