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

public class foxdinner {
  private static InputReader in;
  private static PrintWriter out;
  
  public static boolean[] prime, matched, mat[];
  public static int N, arr[], next[], prev[];

  public static void main(String[] args) throws IOException {
    in = new InputReader(System.in);
    out = new PrintWriter(System.out, true);
    N = in.nextInt();
    if (N%2 == 1) {
      out.println("Impossible");
      out.close();
      System.exit(0);
    }
    int c = 0;
    arr = new int[N];
    for (int i = 0; i < N; i++) {
      arr[i] = in.nextInt();
      if (arr[i]%2 == 0) c++;
      else c--;
    }
    if (c != 0) {
      out.println("Impossible");
      out.close();
      System.exit(0);
    }
    prime = new boolean[50000];
    Arrays.fill(prime, true);
    prime[0] = false; prime[1] = false;
    for (int i = 4; i < prime.length; i += 2) prime[i] = false;
    for (int i = 3; i < prime.length; i += 2) {
      if (prime[i]) {
        for (int j = i+i; j < prime.length; j += i)
          prime[j] = false;
      }
    }
    
    mat = new boolean[N][N];
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
        mat[i][j] = prime[arr[i] + arr[j]];
      }
    }
    
    next = new int[N];
    prev = new int[N];
    matched = new boolean[N];
    Arrays.fill(next, -1);
    Arrays.fill(prev, -1);
    int m = 0;
    for (int i = 0; i < N; i++) {
      vis = new boolean[N];
      if (dfs(i)) m++;
    }
    if (m != N) out.println("Impossible");
    else {
      ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();
      boolean[] vis = new boolean[N];
      for (int i = 0; i < N; i++) {
        if (vis[i]) continue;
        int q = i;
        ArrayList<Integer> add = new ArrayList<Integer>();
        do {
          vis[q] = true;
          add.add(q+1);
          q = next[q];
        } while (q != i);
        ans.add(add);
      }
      out.println(ans.size());
      for (ArrayList<Integer> r : ans) {
        out.print(r.size());
        for (int k : r) out.print(" "+k);
        out.println();
      }
      out.close();
      System.exit(0);
    }
  }
  
  public static boolean[] vis;
  public static boolean dfs(int i) {
    vis[i] = true;
    for (int j = 0; j < N; j++) {
      if (prev[i] != j && mat[i][j]) {
        if (!matched[j]) {
          next[i] = j;
          prev[j] = i;
          matched[j] = true;
          return true;
        } else {
          if (!vis[prev[j]] && dfs(prev[j])) {
            next[i] = j;
            prev[j] = i;
            matched[j] = true;
            return true;
          }
        }
      }
    }
    return false;
  }

  static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
      reader = new BufferedReader(new InputStreamReader(stream), 32768);
      tokenizer = null;
    }

    public String next() {
      while (tokenizer == null || !tokenizer.hasMoreTokens()) {
        try {
          tokenizer = new StringTokenizer(reader.readLine());
        } catch (IOException e) {
          throw new RuntimeException(e);
        }
      }
      return tokenizer.nextToken();
    }

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


}