Problem: Fox Ciel is participating in a party in Prime Kingdom. There are n foxes there (include Fox Ciel). The i-th fox is ai years old.

They will have dinner around some round tables. You want to distribute foxes such that:

  1. Each fox is sitting at some table. 
  2. Each table has at least 3 foxes sitting around it. 
  3. The sum of ages of any two adjacent foxes around each table should be a prime number. 



If k foxes f1, f2, ..., fk are sitting around table in clockwise order, then for 1 ≤ i ≤ k - 1: fi and fi + 1 are adjacent, and f1 and fk are also adjacent.

If it is possible to distribute the foxes in the desired manner, find out a way to do that.

Input

The first line contains single integer n (3 ≤ n ≤ 200): the number of foxes in this party. 

The second line contains n integers ai (2 ≤ ai ≤ 104).

Output

If it is impossible to do this, output "Impossible".

Otherwise, in the first line output an integer m (<image>): the number of tables.

Then output m lines, each line should start with an integer k -=– the number of foxes around that table, and then k numbers — indices of fox sitting around that table in clockwise order.

If there are several possible arrangements, output any of them.

Examples

Input

4
3 4 8 9


Output

1
4 1 2 4 3


Input

5
2 2 2 2 2


Output

Impossible


Input

12
2 3 4 5 6 7 8 9 10 11 12 13


Output

1
12 1 2 3 6 5 12 9 8 7 10 11 4


Input

24
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25


Output

3
6 1 2 3 6 5 4
10 7 8 9 12 15 14 13 16 11 10
8 17 18 23 22 19 20 21 24

Note

In example 1, they can sit around one table, their ages are: 3-8-9-4, adjacent sums are: 11, 17, 13 and 7, all those integers are primes.

In example 2, it is not possible: the sum of 2+2 = 4 is not a prime number.

Solution (in JAVA):

Solution:
/*
 *
 * @author Mukesh Singh
 *
 */

import java.io.*;
import java.util.*;
import java.text.DecimalFormat;
@SuppressWarnings("unchecked")
public class AB
{	
	
	//solve test cases
	void solve() throws Exception 
	{
		int n = in.nextInt();
		int[] age = new int[n];
		for(int i = 0 ; i < n ; ++i)
			age[i] = in.nextInt();
		//find all primes 2-20000
		int[] ar = new int[20001];
		boolean[] isPrime = new boolean[20001];
		for(int i = 2 ; i <= 20000 ; ++i)
		{
			int temp = i ;
			if(ar[i]==0)
			{
				isPrime[i] = true ;
				while(temp <= 20000)
				{
					++ar[temp];
					temp+=i;
				}
			}
		}
		//create maxflow graph
		int[][] gr = new int[n+2][n+2];
		int s = n ;
		int t = n+1 ;
		for(int i = 0 ; i < n ; ++i)
		{
			if(age[i]%2==0)
				gr[s][i] = 2 ;
			if(age[i]%2==1)
				gr[i][t]= 2 ;
			for(int j = 0 ; j < n ; ++j)
			{
				if(isPrime[age[i]+age[j]])
				{
					if( age[i]%2==0)
						gr[i][j] = 1 ;
					else
						gr[j][i] = 1 ;
				}
			}
		}
		int[][] f = new int[n+2][n+2];
		if(flow(n+2 , gr,f,s,t)!= n)
		{
			System.out.println("Impossible");
			return ;
		}
		else
		{
			//print cycles
			List<List<Integer>> ls = new ArrayList<>();
			boolean[] mark = new boolean[n];
			for(int i = 0 ; i < n ; ++i)
			{
				if(!mark[i])
				{
					List<Integer> ls1 = new ArrayList<>();
					int cur = i ;
					outer:while(true)
					{
						mark[cur] = true ;
						ls1.add(cur);
						for(int j = 0 ; j < n ; j++)
						{
							if(!mark[j] && f[cur][j] != 0)
							{
								cur = j ;
								continue outer;
							}
						}
						break;
					}
					ls.add(ls1);
				}
			}
			//print
			System.out.println(ls.size());
			for(List<Integer> ls1 : ls)
			{
				System.out.print(ls1.size()+" ");
				for(int a : ls1)
					System.out.print((a+1)+" ");
				System.out.println();
			}
		}
	}
	int flow(int n , int[][]c , int[][]f , int s , int t)
	{
		boolean[] mark = new boolean[n];
		int res = 0 ;
		while(dfs(s,t,c,f,mark))
		{
			//System.out.println("ff");
			res++ ;
			Arrays.fill(mark , false);
		}
		return res ;
	}
	boolean dfs(int at ,int t , int[][] c , int[][] f , boolean[] mark)
	{
		if(at==t)
			return true ;
		if(mark[at])
			return false ;
		mark[at] = true ;
		for(int i = 0 ; i < c.length ; ++i)
		{
			if(f[at][i] < c[at][i] && dfs(i , t ,  c, f , mark))
			{
				++f[at][i];
				--f[i][at];
				return true ;
			}
		}
		return false ;
	}
	//@ main function
	public static void main(String[] args) throws Exception 
	{
		new AB();
	}
	
	InputReader in;
	PrintStream out ;
	DecimalFormat df ;
	AB() 
	{
		try 
		{
			File defaultInput = new File("file.in");
			if (defaultInput.exists()) 
				in = new InputReader("file.in");
			else 
				in = new InputReader();
			defaultInput = new File("file.out");
			if (defaultInput.exists()) 
				out = new PrintStream(new FileOutputStream("file.out"));
			else
				out = new PrintStream(System.out);
			df = new DecimalFormat("######0.00");
			solve();
			out.close();
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
			System.exit(261);
		}
	}
	
	class InputReader {
		BufferedReader reader;
		StringTokenizer tokenizer;
		
		InputReader() {
			reader = new BufferedReader(new InputStreamReader(System.in));
		}
		
		InputReader(String fileName) throws FileNotFoundException {
			reader = new BufferedReader(new FileReader(new File(fileName)));
		}
		
		String readLine() throws IOException {
			return reader.readLine();
		}
		
		String nextToken() throws IOException {
			while (tokenizer == null || !tokenizer.hasMoreTokens())
				tokenizer = new StringTokenizer(readLine());
			return tokenizer.nextToken();
		}
		
		boolean hasMoreTokens() throws IOException {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				String s = readLine();
				if (s == null)
					return false;
				tokenizer = new StringTokenizer(s);
			}
			return true;
		}
		
		int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(nextToken());
		}
		
		long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(nextToken());
		}
		
		double nextDouble() throws NumberFormatException, IOException {
			return Double.parseDouble(nextToken());
		}
	}
}