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;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/**
 * Created by z002rgw on 9/4/17.
 */
public class TaskC432Div2 {
    public static class Point {
        int x, y, z, u, v;
        Point(Integer x, Integer y, Integer z, Integer u, Integer v){
            this.x = x;
            this.y = y;
            this.z = z;
            this.u = u;
            this.v = v;
        }

        @Override
        public String toString(){
            return x + " " + y + " " + z + " " + u + " " + v;
        }
    }
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        // Start writing your solution here. -------------------------------------

        /*
            int n      = sc.nextInt();        // read input as integer
            long k     = sc.nextLong();       // read input as long
            double d   = sc.nextDouble();     // read input as double
            String str = sc.next();           // read input as String
            String s   = sc.nextLine();       // read whole line as String

            int result = 3*n;
            out.println(result);                    // print via PrintWriter
        */

        // Stop writing your solution here. -------------------------------------
        BufferedReader br;
        StringTokenizer st;

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

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }

    public static void main(String[] args) {
        TaskC432Div2.MyScanner in = new TaskC432Div2.MyScanner();
        int n = in.nextInt();
        List<Point> points = new ArrayList<Point>(n);
        for(int i = 0; i < n; i++){
            int x = in.nextInt();
            int y = in.nextInt();
            int z = in.nextInt();
            int u = in.nextInt();
            int v = in.nextInt();

            TaskC432Div2.Point point = new TaskC432Div2.Point(x, y, z, u, v);
            points.add(point);
        }

        Boolean[] isAcute = new Boolean[n];
        for(int i = 0; i < n; i++){
            isAcute[i] = false;
        }

        int count = n;

        for(int i = 0; i < n; i++){
            if(isAcute[i])
                continue;
            for(int j = 0; j < n; j++){
                if(isAcute[i])
                    break;
                for(int k = j + 1; k < n; k++){
                    if(isAcute[i])
                        break;
                    //System.out.println("i: " + i + " j: " + j + " k: " + k);
                    if(i == j || j == k || k == i){
                        continue;
                    } else if(!isAcute[i]) {
                        isAcute[i] = isAcute(points, i, j , k);
                        if(isAcute[i] == false){
                            isAcute[j] = true;
                            isAcute[k] = true;
                        }
                    }
                }
            }
        }

        for(int i = 0; i < n; i++){
            if(isAcute[i]){
               count = count - 1;
            }
        }

        System.out.println(count);

        if(count != 0){
            for(int i = 0; i < n; i++){
                if(!isAcute[i])
                    System.out.println(i + 1);
            }
        }
    }

    private static Boolean isAcute(List<Point> points, int i, int j, int k) {
        Point A = points.get(i);
        Point B = points.get(j);
        Point C = points.get(k);
        Point D = new Point(B.x - A.x, B.y - A.y, B.z - A.z, B.u - A.u, B.v - A.v);
        Point E = new Point(C.x - A.x, C.y - A.y, C.z - A.z, C.u - A.u, C.v - A.v);
        int product = D.x * E.x + D.y * E.y + D.z * E.z + D.u * E.u + D.v * E.v;
        if(product > 0)
            return true;
        return false;
    }
}
