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

public class Template {

    BufferedReader in;
    PrintWriter out;
    StringTokenizer st;

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(in.readLine());
            } catch (Exception e) {
            }
        }
        return st.nextToken();
    }

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

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

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

    public void run() throws Exception {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        solve();
        out.flush();
        out.close();
        in.close();
    }

    public void solve() throws Exception {
        int n = nextInt();
        long[][] x = new long[n][5];
        for (int i = 0; i < n; i++) {
            x[i][0] = nextLong();
            x[i][1] = nextLong();
            x[i][2] = nextLong();
            x[i][3] = nextLong();
            x[i][4] = nextLong();
        }

        // only one point can be good
        boolean[] good = new boolean[n];
        Arrays.fill(good, true);

        for (int i = 0; i < n; i++) {
            if (!good[i]) {
                continue;
            }
            for (int j = 0; j < n; j++) {
                if (!good[i]) {
                    break;
                }
                if (j == i) {
                    continue;
                }
                for (int k = 0; k < n; k++) {
                    if (k == i || k == j) {
                        continue;
                    }
                    if (isGood(x[i], x[j], x[k])) {
                        good[j] = false;
                        good[k] = false;
                    } else {
                        good[i] = false;
                        break;
                    }
                }
            }
        }

        // out println ans
        int ans = 0;
        for (int i = 0; i < n; i++) {
            if (good[i]) {
                ans++;
            }
        }

        out.println(ans);
        if (ans > 0) {
            for (int i = 0; i < n; i++) {
                if (good[i]) {
                    out.print((i + 1) + " ");
                }
            }
            out.println();
        }
    }

    public boolean isGood(long[] a, long[] b, long[] c) {
        long[] ab = new long[5];
        long[] ac = new long[5];
        for (int i = 0; i < 5; i++) {
            ab[i] = a[i] - b[i];
            ac[i] = a[i] - c[i];
        }

        double scalar = 0;
        double mab = 0;
        double mac = 0;
        for (int i = 0; i < 5; i++) {
            scalar += ab[i] * ac[i];
            mab += ab[i] * ab[i];
            mac += ac[i] * ac[i];
        }
        mab = Math.sqrt(mab);
        mac = Math.sqrt(mac);

        double cos = scalar / (mab * mac);

        return cos <= 0;
    }

    public long gcd(long a, long b) {
        long x = a, y = b;
        while (y > 0) {
            x %= y;
            long temp = x;
            x = y;
            y = temp;
        }
        return x;
    }

    public static void main(String[] args) throws Exception {
        new Template().run();
    }
}
