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.Arrays;
import java.util.Comparator;

public class C5Dimension {

  private static final String REGEX = " ";
  private static final Boolean DEBUG = false;
  private static final String FILE_NAME = "input.txt";


  public static void main(String[] args) throws IOException {
    if (DEBUG) {
      generate();
    }
    Solver solver = new Solver();
    solver.readData();
    solver.solve();
    solver.print();
  }

  private static void generate() throws IOException {
//    FileWriter writer = new FileWriter("input.txt");
//    writer.close();
  }

  private static class Solver {
    static class Point {
      int a, b, c, d, e;

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

    static class Vector {
      Point start, end;

      public Vector(Point start, Point end) {
        this.start = start;
        this.end = end;
      }
    }

    private StringBuilder myStringBuilder = new StringBuilder();
    int n;
    Point[] points;


    void readData() throws IOException {
      Scanner scanner = new Scanner();
      n = scanner.nextInt();
      points = new Point[n];
      int a, b, c, d, e;
      for (int i = 0; i < n; i++) {
        a = scanner.nextInt();
        b = scanner.nextInt();
        c = scanner.nextInt();
        d = scanner.nextInt();
        e = scanner.nextInt();
        points[i] = new Point(a, b, c, d, e);
      }
      scanner.close();
    }

    void solve() {
      boolean[] result = new boolean[n];
      int resSize = 0;
      if (n < 3) {
        resSize = n;
        for (int i = 0; i < n; i++) {
          result[i] = true;
        }
      } else {
        for (int i = 0; i < n; i++) {
          Vector[] vectors = new Vector[n - 2];
          int baseEnd = i == 0 ? 1 : 0;
          final Vector baseVector = new Vector(points[i], points[baseEnd]);
          fillVector(vectors, i, baseEnd);
          final double mod = Math.sqrt(((double) mult(baseVector, baseVector)));
          Comparator<Vector> comparator = (o1, o2) -> {
            double mult1 = ((double) mult(baseVector, o1));
            double mult2 = ((double) mult(baseVector, o2));

            mult1 /= (Math.sqrt(((double) mult(o1, o1))) * mod);
            mult2 /= (Math.sqrt(((double) mult(o2, o2))) * mod);
            if (mult1 > mult2) {
              return  -1;
            } else if (mult1 == mult2) {
              return 0;
            } else {
              return 1;
            }
          };
          Arrays.sort(vectors, comparator);
          Vector firstVector = baseVector;
          Vector secondVector;
          boolean foundSharp = false;
          for (Vector vector : vectors) {
            secondVector = vector;
            if (isSharp(firstVector, secondVector)) {
              foundSharp = true;
              break;
            }
            firstVector = vector;
          }
          if (!foundSharp) {
            result[i] = true;
            resSize++;
          }
        }
      }
      out(resSize);
      if (resSize > 0) {
        out('\n');
        for (int i = 0; i < n; i++) {
          if (result[i]) {
            out(i + 1);
            out('\n');
          }
        }
      }
    }

    boolean isSharp(Vector v1, Vector v2) {
      int mult = mult(v1, v2);
      return mult > 0;
    }

    private int mult(Vector v1, Vector v2) {
      int x1 = v1.end.a - v1.start.a;
      int x2 = v1.end.b - v1.start.b;
      int x3 = v1.end.c - v1.start.c;
      int x4 = v1.end.d - v1.start.d;
      int x5 = v1.end.e - v1.start.e;

      int y1 = v2.end.a - v2.start.a;
      int y2 = v2.end.b - v2.start.b;
      int y3 = v2.end.c - v2.start.c;
      int y4 = v2.end.d - v2.start.d;
      int y5 = v2.end.e - v2.start.e;

      return x1 * y1 + x2 * y2 + x3 * y3 + x4 * y4 + x5 * y5;
    }

    private void fillVector(Vector[] vectors, int start, int miss) {
      int cur = 0;
      for (int i = 0; i < n; i++) {
        if (start == i || miss == i) {
          continue;
        }
        vectors[cur++] = new Vector(points[start], points[i]);
      }
    }

    void print() {
      System.out.println(myStringBuilder);
    }


    void out(Object object) {
      myStringBuilder.append(object);
    }

    void out(String string) {
      myStringBuilder.append(string);
    }

    public void out(boolean b) {
      myStringBuilder.append(b);
    }

    public void out(char c) {
      myStringBuilder.append(c);
    }

    public void out(int i) {
      myStringBuilder.append(i);
    }

    public void out(long lng) {
      myStringBuilder.append(lng);
    }

    public void out(float f) {
      myStringBuilder.append(f);
    }

    public void out(double d) {
      myStringBuilder.append(d);
    }

    public void newLine() {
      myStringBuilder.append("\n");
    }

    @SuppressWarnings("SameParameterValue")
    int[] splitInteger(String string, int n) {
      final String[] split = string.split(REGEX, n);
      int[] result = new int[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Integer.parseInt(split[i]);
      }
      return result;
    }

    public int[] splitInteger(String string) {
      return splitInteger(string, 0);
    }


    @SuppressWarnings("SameParameterValue")
    long[] splitLong(String string, int n) {
      final String[] split = string.split(REGEX, n);
      long[] result = new long[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Long.parseLong(split[i]);
      }
      return result;
    }

    public long[] splitLong(String string) {
      return splitLong(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    double[] splitDouble(String string, int n) {
      final String[] split = string.split(REGEX, n);
      double[] result = new double[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Double.parseDouble(split[i]);
      }
      return result;
    }

    public double[] splitDouble(String string) {
      return splitDouble(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    String[] splitString(String string, int n) {
      return string.split(REGEX, n);
    }

    public int max(int a, int b) {
      return Math.max(a, b);
    }

    public int max(int[] arr) {
      int max = Integer.MIN_VALUE;
      for (int x : arr) {
        max = max(max, x);
      }
      return max;
    }

    public long max(long a, long b) {
      return Math.max(a, b);
    }

    public int min(int a, int b) {
      return Math.min(a, b);
    }

    public long min(long a, long b) {
      return Math.min(a, b);
    }

    public double max(double a, double b) {
      return Math.max(a, b);
    }

    public double min(double a, double b) {
      return Math.min(a, b);
    }

    private final static int MOD = 1000000009;

    int multMod(int a, int b) {
      return ((a % MOD) * (b % MOD)) % MOD;
    }

    int sumMod(int a, int b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }

    long multMod(long a, long b) {
      return ((a % MOD) * (b % MOD)) % MOD;
    }

    long sumMod(long a, long b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }

    int sum(int[] arr) {
      int sum = 0;
      for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
      }
      return sum;
    }

    long sum(long[] arr) {
      long sum = 0;
      for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
      }
      return sum;
    }

    private class Scanner {
      private int currentIndex = 0;
      private String[] objects;
      private final BufferedReader myReader;
      private Computable<Character> charComputer;
      private Computable<Double> doubleComputer;
      private Computable<Integer> intComputer;
      private Computable<Long> longComputer;

      Scanner() throws FileNotFoundException {
        InputStream in = DEBUG ? new FileInputStream(FILE_NAME) : System.in;
        myReader = new BufferedReader(new InputStreamReader(in));
        charComputer = () -> objects[currentIndex].charAt(0);
        doubleComputer = () -> Double.parseDouble(objects[currentIndex]);
        intComputer = () -> Integer.parseInt(objects[currentIndex]);
        longComputer = () -> Long.parseLong(objects[currentIndex]);
      }

      String nextLine() throws IOException {
        objects = null;
        currentIndex = 0;
        return myReader.readLine();
      }

      int nextInt() throws IOException {
        return next(intComputer);
      }

      int[] nextIntArray(int n) throws IOException {
        return splitInteger(nextLine(), n);
      }

      long[] nextLongArray(int n) throws IOException {
        return splitLong(nextLine(), n);
      }

      long nextLong() throws IOException {
        return next(longComputer);

      }

      double nextDouble() throws IOException {
        return next(doubleComputer);

      }

      char nextChar() throws IOException {
        return next(charComputer);
      }

      <T> T next(Computable<T> computer) throws IOException {
        T result;
        if (objects == null || currentIndex >= objects.length) {
          String s = myReader.readLine();
          objects = s.split(" ");
          currentIndex = 0;
        }
        result = computer.compute();
        currentIndex++;
        return result;
      }

      public void close() throws IOException {
        myReader.close();
      }

    }

    interface Computable<T> {
      T compute();
    }

  }

}
