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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.Comparator;
import java.io.InputStream;


public class Main
{
    static int n;
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static double x[][] = new double[1005][5];
    static boolean bad[] = new boolean[1005];

   static boolean check(int a, int b, int c) {
        int p=0;
        for (int i=0; i<5; i++) {
            p+=(x[b][i]-x[a][i])*(x[c][i]-x[a][i]);
        }
        if (p>0) return true;
        else return false;
    }

    static class TaskD
    {



        public void solve(int testNumber, InputReader in, PrintWriter out)
        {
            // zzzzz
            Random random = new Random(94739534513L + System.currentTimeMillis());
             n = in.nextInt();

          
            for (int i=0; i<n; i++) {
                for (int j=0; j<5; j++)
                    x[i][j] = in.nextInt();
            }
            for (int a = 0; a<n; a++)
            {
                if (!bad[a]) 
                {
                    for (int b = a + 1; b < n; b++) 
                    {
                        for (int c = b + 1; c < n; c++) 
                        {
                            if (bad[a] || check(a,b,c)) bad[a] = true;
                            if (bad[b] || check(b,a,c)) bad[b] = true;
                            if (bad[c] || check(c,a,b)) bad[c] = true;
                        }
                    }
                }
            }
            int good = 0;
            for (int i=0; i<n; i++)
                if (!bad[i]) good++;
            out.println(good);
            for (int i=0; i<n; i++)
                if (!bad[i]) out.println(i + 1);
        }



        }





    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }
}