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

import java.math.*;



public class Main {

    

    public static int inf=0x3f3f3f3f;

    public static int NN=210, MM=40410, maxn=200010, E=0, runs=0, qf, qb;

    

    public static int[] a=new int[NN], f=new int[maxn];

    public static int[] deg=new int[NN], vst=new int[NN];

    public static int[] pre=new int[NN], q=new int[NN], dis=new int[NN];

    public static int[] head=new int[NN], nxt=new int[MM], to=new int[MM];

    public static int[][] cap=new int[NN][NN], adj=new int[NN][NN];

    

    public static void init() {

        for(int i=0; i<NN; i++) head[i]=-1;

        for(int i=2; i<maxn; i++) if(f[i]==0 && (long)i*i<maxn) {

            for(int j=i*i; j<maxn; j+=i) f[j]=1;

        }

    }

    

    public static void add(int u, int v, int c) {

        nxt[E]=head[u]; head[u]=E; to[E++]=v;

        nxt[E]=head[v]; head[v]=E; to[E++]=u;

        cap[u][v]=c;

    }

    

    public static int dinic(int src, int tar) {

        int ans=0;

        while(true) {

            qb=qf=0;

            q[qb++]=src;

            for(int i=0; i<NN; i++) pre[i]=-1;

            

            while(qb>qf && pre[tar]==-1) {

                int u=q[qf++];

                for(int e=head[u]; e!=-1; e=nxt[e]) {

                    int v=to[e];

                    if(pre[v]==-1 && cap[u][v]!=0) {

                        q[qb++]=v;

                        pre[v]=u;

                    }

                }

            }



            while(qb>qf && pre[tar]==-1) {

                int u=q[qf++];

                for(int e=head[u]; e!=-1; e=nxt[e]) {

                    int v=to[e];

                    if(pre[v]==-1 && cap[u][v]!=0) {

                        q[qb++]=v;

                        pre[v]=u;

                    }

                }

            }



            if(pre[tar]==-1) return ans;

            

            int bot=inf;

            for(int u=tar; u!=src; u=pre[u]) {

                if(cap[pre[u]][u]<bot) bot=cap[pre[u]][u];

            }

            

            ans+=bot;

            for(int u=tar; u!=src; u=pre[u]) {

                cap[pre[u]][u]-=bot;

                cap[u][pre[u]]+=bot;

            }

        }

    }

    

    public static int[] cnt=new int[NN];

    public static int[][] ans=new int[NN][NN];

    

    public static void dfs(int u) {

        ans[runs][cnt[runs]++]=u;

        vst[u]=1;

        for(int i=0; i<deg[u]; i++) {

            int v=adj[u][i];

            if(vst[v]==0) dfs(v);

        }

    }

    

    public static void main(String[] args) {

        Scanner in=new Scanner(System.in);

        

        init();

        

        int n=in.nextInt();

        for(int i=1; i<=n; i++) a[i]=in.nextInt();

        

        int src=0, tar=n+1;

        for(int i=1; i<=n; i++) {

            if(a[i]%2==0) add(src, i, 2);

            else add(i, tar, 2);

            

            if(a[i]%2==0) {

                for(int j=1; j<=n; j++) {

                    if(f[a[i]+a[j]]==0) add(i, j, 1);

                }

            }

        }

        

        int flow=dinic(src, tar);

        if(flow!=n) {System.out.println("Impossible"); System.exit(0);}

        

        for(int i=1; i<=n; i++) {

            for(int j=1; j<=n; j++) if(a[j]%2==0) {

                if(cap[i][j]!=0) {adj[i][deg[i]++]=j; adj[j][deg[j]++]=i;}

            }

        }

        

        for(int i=1; i<=n; i++) if(vst[i]==0) {runs++; dfs(i);}

        

        System.out.println(runs);

        for(int i=1; i<=runs; i++) {

            System.out.print(cnt[i]+" ");

            for(int j=0; j<cnt[i]; j++) System.out.print(ans[i][j]+" ");

            System.out.println();

        }

    }

}