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.*;

public class J implements Runnable {

  private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

  private BufferedReader in;
  private PrintWriter out;
  private StringTokenizer tok = new StringTokenizer("");

  private void init() throws FileNotFoundException {
    Locale.setDefault(Locale.US);
    String fileName = "";
    in = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);

  }

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

  int readInt() {
    return Integer.parseInt(readString());
  }

  long readLong() {
    return Long.parseLong(readString());
  }

  double readDouble() {
    return Double.parseDouble(readString());
  }

  int[] readIntArray(int size) {
    int[] a = new int[size];
    for (int i = 0; i < size; i++) {
      a[i] = readInt();
    }
    return a;
  }

  public static void main(String[] args) {
    //new Thread(null, new _Solution(), "", 128 * (1L << 20)).start();
    new J().run();
  }

  long timeBegin, timeEnd;

  void time() {
    timeEnd = System.currentTimeMillis();
    // System.err.println("Time = " + (timeEnd - timeBegin));
  }

  @Override
  public void run() {
    try {
      timeBegin = System.currentTimeMillis();
      init();
      solve();
      out.close();
      time();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(-1);
    }
  }

  private int aiverson(boolean good) {
    return good ? 1 : 0;
  }

  boolean isDigit(char x) {
    return x == '0' || x == '1';
  }


  private void solve() throws IOException {
    int n = readInt();
    Point[] points = new Point[n];
    for (int i = 0; i < n; i++) {
      points[i] = new Point(readInt(), readInt(), readInt(), readInt(), readInt(), i);
    }
    Deque<Point> probGood = new ArrayDeque<>();
    probGood.addAll(Arrays.asList(points));
    while (probGood.size() > 2) {
      Point first = probGood.pollFirst();
      Point second = probGood.pollFirst();
      Point third = probGood.pollFirst();
      if (isGood(first, second, third)) {
        probGood.add(first);
        continue;
      }
      if (isGood(second, first, third)) {
        probGood.add(second);
        continue;
      }
      if (isGood(third, second, first)) {
        probGood.add(third);
        continue;
      }
    }
    List<Integer> ans = new ArrayList<>();
    for (Point p : probGood) {
      boolean found = false;
      for (int i = 0; i < n; i++) {
        if (p != points[i]) {
          for (int j = i + 1; j < n; j++) {
            if (p != points[j]) {
              if (!isGood(p, points[i], points[j])) {
                found = true;
                break;
              }
            }
          }
        }
      }
      if (!found) ans.add(p.index + 1);
    }
    out.println(ans.size());
    for (int x : ans) {
      out.println(x);
    }
  }

  boolean isGood(Point a, Point b, Point c) {
    return cos(a, b, c) <= 0;
  }

  private int cos(Point ap, Point b, Point c) {
    int a1 = b.a - ap.a;
    int b1 = b.b - ap.b;
    int c1 = b.c - ap.c;
    int d1 = b.d - ap.d;
    int e1 = b.e - ap.e;
    int a2 = c.a - ap.a;
    int b2 = c.b - ap.b;
    int c2 = c.c - ap.c;
    int d2 = c.d - ap.d;
    int e2 = c.e - ap.e;
    return a1 * a2 + b1 * b2 + c1 * c2 + d1 * d2 + e1 * e2;
  }


  class Point {
    int a, b, c, d, e, index;

    public Point(int a, int b, int c, int d, int e, int index) {
      this.a = a;
      this.b = b;
      this.c = c;
      this.d = d;
      this.e = e;
      this.index = index;
    }
  }


}
