You are given array a with n elements and the number m. Consider some subsequence of a and the value of least common multiple (LCM) of its elements. Denote LCM as l. Find any longest subsequence of a with the value l ≤ m.

A subsequence of a is an array we can get by erasing some elements of a. It is allowed to erase zero or all elements.

The LCM of an empty array equals 1.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the size of the array a and the parameter from the problem statement.

The second line contains n integers ai (1 ≤ ai ≤ 109) — the elements of a.

Output

In the first line print two integers l and kmax (1 ≤ l ≤ m, 0 ≤ kmax ≤ n) — the value of LCM and the number of elements in optimal subsequence.

In the second line print kmax integers — the positions of the elements from the optimal subsequence in the ascending order.

Note that you can find and print any subsequence with the maximum length.

Examples

Input

7 8
6 2 9 2 7 2 3


Output

6 5
1 2 4 6 7


Input

6 4
2 2 2 3 3 3


Output

2 3
1 2 3

import java.io.*;
import java.util.*;

public class D {
	InputStream is;

	int __t__ = 1;
	int __f__ = 0;
	int __FILE_DEBUG_FLAG__ = __f__;
	String __DEBUG_FILE_NAME__ = "src/D1";

	FastScanner in;
	PrintWriter out;

	int MAX = 1000100;
	int[] memo = new int[MAX];
	HashMap<Integer, Integer> map = new HashMap<>();

	static final int PRIME_LIST_SIZE = 50000;
	static boolean[] primeList;
	static {
		primeList = getPrimeList(PRIME_LIST_SIZE);
	}
	static boolean isPrime(int n) {
		if (n < 0) return false;
		return primeList[n];
	}
	
	static boolean[] getPrimeList(int n) {
		boolean[] res = new boolean[n+1];
		
		Arrays.fill(res, true);

		res[0] = res[1] = false;
		for (int i = 2; i < res.length; i++) {
			if (!res[i]) continue;
			for (int j = 2 * i; j < res.length; j += i) {
				res[j] = false;
			}
		}
		
		return res;
	}

	long gcd(long x, long y) {
		if (x == 0 || y == 0) return x + y;
		return gcd(y, x % y);
	}

	long lcm(long x, long y) {
		return x * (y / gcd(x, y));
	}

	int dfs(int value) {
		if (memo[value] != Integer.MAX_VALUE) return memo[value];
		
		int res = map.containsKey(value) ? map.get(value) : 0;
		int cur = value;
		for (int p = 2; (long) p * p <= cur; p++) {
			if (cur % p == 0)
				res += dfs(value / p);
			while (cur % p == 0) 
				cur /= p;
		}
		if (cur != 1 && (value / cur) != 1) res += dfs(value / cur);
		memo[value] = res;
		return res + (value == 1 ? 0 : dfs(1));
	}
	
	public void solve() {
		/* expr
		long total = 0;
		for (int t = 2; t <= 100000; t++) {
			long num = 1;
			long cur = t;
			for (int i = 2; i <= cur * cur; i++) {
				int cnt = 0;
				while (cur % i == 0) {
					cur /= i;
					cnt++;
				}
				num *= (cnt + 1);
			}
			if (cur != 1) num *= 2;
			total += num;
			System.out.println(t + " : " + num + " " + total);
		}
		System.out.println(total);
		*/
		
		/*
		int n = in.nextInt(), m = in.nextInt();
		int[] a = in.nextIntArray(n);
		for (int i = 0; i < n; i++) {
			if (map.containsKey(a[i]))
				map.put(a[i], map.get(a[i]) + 1);
			else
				map.put(a[i], 1);
		}
		
		Arrays.fill(memo, Integer.MAX_VALUE);
		int max = -1, value = -1;
		for (int next = m; next > 0; next--) {
			int cur = dfs(next);
			if (cur >= max) {
				value = next;
				max = cur;
			}
		}
		
		out.println(value + " " + max);
		int ansNum = 0;
		for (int i = 0; i < n; i++) {
			if (gcd(value, a[i]) == a[i]) { 
				out.println((i+1) + " ");
				ansNum++;
			}
		}
		out.close();
		*/
		int n = in.nextInt(), m = in.nextInt();
		int[] a = in.nextIntArray(n);
		
		int[] cnt = new int[m+1];
		for (int i = 0; i < n; i++) {
			if (a[i] <= m) cnt[a[i]]++;
		}
		int[] p = new int[m+1];
		for (int i = 1; i <= m; i++) {
			for (int j = i; j <= m; j += i) {
				p[j] += cnt[i];
			}
		}
		
		int value = -1, max = -1;
		for (int i = 1; i <= m; i++) {
			if (p[i] > max) {
				max = p[i];
				value = i; 
			}
		}
		out.println(value + " " + max);
		int ansNum = 0;
		for (int i = 0; i < n; i++) {
			if (gcd(value, a[i]) == a[i]) { 
				out.println((i+1) + " ");
				ansNum++;
			}
		}
		out.close();
	}

	public void run() {
		if (__FILE_DEBUG_FLAG__ == __t__) {
			try {
				is = new FileInputStream(__DEBUG_FILE_NAME__);
			} catch (FileNotFoundException e) {
				// TODO 自動生成された catch ブロック
				e.printStackTrace();
			}
			System.out.println("FILE_INPUT!");
		} else {
			is = System.in;
		}
		in = new FastScanner(is);
		out = new PrintWriter(System.out);

		solve();
	}

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

	public void mapDebug(int[][] a) {
		System.out.println("--------map display---------");

		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				System.out.printf("%3d ", a[i][j]);
			}
			System.out.println();
		}

		System.out.println("----------------------------");
		System.out.println();
	}

	public void debug(Object... obj) {
		System.out.println(Arrays.deepToString(obj));
	}

	class FastScanner {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public FastScanner(InputStream stream) {
			this.stream = stream;
			//stream = new FileInputStream(new File("dec.in"));

		}

		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++];
		}

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

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

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

		int[] nextIntArray(int n) {
			return nextIntArray(n, 0);
		}

		int[] nextIntArray(int n, int margin) {
			int[] array = new int[n + margin];
			for (int i = 0; i < n; i++)
				array[i + margin] = nextInt();

			return array;
		}

		int[][] nextIntMap(int n, int m) {
			int[][] map = new int[n][m];
			for (int i = 0; i < n; i++) {
				map[i] = in.nextIntArray(m);
			}
			return map;
		}

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

		long[] nextLongArray(int n) {
			return nextLongArray(n, 0);
		}

		long[] nextLongArray(int n, int margin) {
			long[] array = new long[n + margin];
			for (int i = 0; i < n; i++)
				array[i + margin] = nextLong();

			return array;
		}

		long[][] nextLongMap(int n, int m) {
			long[][] map = new long[n][m];
			for (int i = 0; i < n; i++) {
				map[i] = in.nextLongArray(m);
			}
			return map;
		}

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

		double[] nextDoubleArray(int n) {
			return nextDoubleArray(n, 0);
		}

		double[] nextDoubleArray(int n, int margin) {
			double[] array = new double[n + margin];
			for (int i = 0; i < n; i++)
				array[i + margin] = nextDouble();

			return array;
		}

		double[][] nextDoubleMap(int n, int m) {
			double[][] map = new double[n][m];
			for (int i = 0; i < n; i++) {
				map[i] = in.nextDoubleArray(m);
			}
			return map;
		}

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

		String[] nextStringArray(int n) {
			String[] array = new String[n];
			for (int i = 0; i < n; i++)
				array[i] = next();

			return array;
		}

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

