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.math.BigInteger;
import java.util.*;




public class Main {
	
	static InputReader in = new InputReader(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	
	
	public static void main(String[] args) {

		int n = in.nextInt();
//		int n = 1000;
//		Random random = new Random();
		
		Point[] p = new Point[n];
		for(int i=0; i<n; ++i) {
			int a = in.nextInt();
			int b = in.nextInt();
			int c = in.nextInt();
			int d = in.nextInt();
			int e = in.nextInt();
			
			p[i] = new Point(a, b, c, d, e);
		}
		
		ArrayList<Integer> ans = new ArrayList<>(); 
		L1:for(int i=0; i<n; ++i) {
			for(int j = 0; j < n; ++j) {
				if(i == j)
					continue;
				for(int k = j + 1; k < n; ++k) {
					if(k == i)
						continue;
					Vect v1 = new Vect(p[i], p[j]);
					Vect v2 = new Vect(p[i], p[k]);
					double angle = angle(v1, v2);
					if(angle < Math.PI / 2)
						continue L1;
				}
			}
			ans.add(i+1);
		}
		
		System.out.println(ans.size());
		for(int i : ans)
			System.out.print(i + " ");
		
		out.close();
	}
	
	static class Point {
		int a, b, c, d, e;

		public Point(int a, int b, int c, int d, int e) {
			super();
			this.a = a;
			this.b = b;
			this.c = c;
			this.d = d;
			this.e = e;
		}
	}
	
	static class Vect {
		Point from, to;
		int a, b, c, d, e;
		
		public Vect(Point x, Point y) {
			this.from = x;
			this.to = y;
			this.a = y.a - x.a;
			this.b = y.b - x.b;
			this.c = y.c - x.c;
			this.d = y.d - x.d;
			this.e = y.e - x.e;
		}
	}
	
	static double angle(Vect x, Vect y) {
		int xy = x.a * y.a + x.b * y.b + x.c * y.c + x.d * y.d + x.e * y.e;
		double dx = Math.sqrt( x.a * x.a + x.b * x.b + x.c * x.c + x.d * x.d + x.e * x.e );
		double dy = Math.sqrt( y.a * y.a + y.b * y.b + y.c * y.c + y.d * y.d + y.e * y.e );
		return Math.acos( xy / (dx * dy) );
	}
	
}


class InputReader {

	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;

	public InputReader(InputStream st) {
		this.stream = st;
	}

	public int read() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		long res = 0;
		do {
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nextIntArray(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
		}
		return a;
	}

	public String readString() {
		int c = read();
		while (isSpaceChar(c)) {
			c = read();
		}
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

}