Problem: Once upon a time an old man and his wife lived by the great blue sea. One day the old man went fishing and caught a real live gold fish. The fish said: "Oh ye, old fisherman! Pray set me free to the ocean and I will grant you with n gifts, any gifts you wish!". Then the fish gave the old man a list of gifts and their prices. Some gifts on the list can have the same names but distinct prices. However, there can't be two gifts with the same names and the same prices. Also, there can be gifts with distinct names and the same prices. The old man can ask for n names of items from the list. If the fish's list has p occurrences of the given name, then the old man can't ask for this name of item more than p times.

The old man knows that if he asks for s gifts of the same name, the fish will randomly (i.e. uniformly amongst all possible choices) choose s gifts of distinct prices with such name from the list. The old man wants to please his greedy wife, so he will choose the n names in such a way that he can get n gifts with the maximum price. Besides, he isn't the brightest of fishermen, so if there are several such ways, he chooses one of them uniformly.

The old man wondered, what is the probability that he can get n most expensive gifts. As the old man isn't good at probability theory, he asks you to help him.

Input

The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 1000) — the number of the old man's wishes and the number of distinct names in the goldfish's list, correspondingly. Then m lines follow: the i-th line first contains integer ki (ki > 0) — the number of distinct prices of gifts with the i-th name, then ki distinct space-separated integers cij (1 ≤ cij ≤ 109), the gifts' prices. 

It is guaranteed that the sum of all ki doesn't exceed 1000. It is guaranteed that n is not greater than the total number of the gifts.

Output

On a single line print one real number — the probability of getting n most valuable gifts. The answer will be considered correct if its absolute or relative error does not exceed 10 - 9.

Examples

Input

3 1
3 10 20 30


Output

1.000000000


Input

3 2
1 40
4 10 20 30 40


Output

0.166666667

Solution (in JAVA):

Solution:
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Egor Kulikov (egor@egork.net)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {
	public void solve(int testNumber, InputReader in, OutputWriter out) {
		int wishCount = in.readInt();
		int titleCount = in.readInt();
		int[][] values = new int[titleCount][];
		for (int i = 0; i < titleCount; i++)
			values[i] = IOUtils.readIntArray(in, in.readInt());
		int total = 0;
		for (int[] row : values)
			total += row.length;
		int[] all = new int[total];
		int index = 0;
		for (int[] row : values) {
			System.arraycopy(row, 0, all, index, row.length);
			index += row.length;
		}
		Arrays.sort(all);
		int smallest = all[total - wishCount];
		int[] shouldTake = new int[titleCount];
		int[] mayTake = new int[titleCount];
		int good = 0;
		int notBad = 0;
		for (int i = 0; i < titleCount; i++) {
			for (int j : values[i]) {
				if (j > smallest) {
					shouldTake[i]++;
					good++;
				} else if (j == smallest) {
					mayTake[i]++;
					notBad++;
				}
			}
		}
		int remaining = good + notBad - wishCount;
		double[] answer = new double[notBad - remaining + 1];
		answer[0] = 1;
		double[] next = new double[answer.length];
		double[][] c = new double[total + 1][total + 1];
		for (int i = 0; i <= total; i++) {
			c[i][0] = 1;
			for (int j = 1; j <= i; j++)
				c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
		}
		int mayTakeRemaining = notBad;
		int willTake = answer.length - 1;
		for (int i = 0; i < titleCount; i++) {
			Arrays.fill(next, 0);
			for (int j = 0; j < answer.length; j++) {
				for (int k = 0; k <= mayTake[i] && j + k < answer.length; k++) {
					if (mayTakeRemaining < mayTake[i] || notBad < j + k)
						continue;
					double probability = c[mayTake[i]][k] * c[mayTakeRemaining - mayTake[i]][willTake - j - k] / c[mayTakeRemaining][willTake - j];
					double win = c[mayTake[i]][k] / c[values[i].length][shouldTake[i] + k];
					next[j + k] += answer[j] * probability * win;
				}
			}
			double[] temp = answer;
			answer = next;
			next = temp;
			mayTakeRemaining -= mayTake[i];
		}
		out.printLine(answer[answer.length - 1]);
	}
}

class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

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

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

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

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

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public OutputWriter(Writer writer) {
		this.writer = new PrintWriter(writer);
	}

	public void print(Object...objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	public void printLine(Object...objects) {
		print(objects);
		writer.println();
	}

	public void close() {
		writer.close();
	}

	}

class IOUtils {

	public static int[] readIntArray(InputReader in, int size) {
		int[] array = new int[size];
		for (int i = 0; i < size; i++)
			array[i] = in.readInt();
		return array;
	}

	}