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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
const int MAXA = 20100;
int N;
int evens = 0, odds = 0;
int A[MAXN];
int cap[MAXN][MAXN];
bool vis[MAXN];
vector<int> adj[MAXN];
bool is_prime[MAXA];
void primes() {
  memset(is_prime, true, sizeof(is_prime));
  for (int i = 2; i < MAXA; ++i)
    if (is_prime[i])
      for (int k = i * 2; k < MAXA; k += i) is_prime[k] = false;
}
bool dfs(int cur) {
  if (cur == (N + 1)) return true;
  if (vis[cur]) return false;
  vis[cur] = true;
  for (int i = 0; i <= N + 1; ++i)
    if (cap[cur][i] && dfs(i)) {
      --cap[cur][i];
      ++cap[i][cur];
      return true;
    }
  return false;
}
void build() {
  memset(cap, 0, sizeof(cap));
  for (int i = 0; i < N; ++i) {
    if (A[i] & 1)
      cap[(N)][i] = 2;
    else
      cap[i][(N + 1)] = 2;
  }
  for (int i = 0; i < N; ++i)
    for (int k = 0; k < N; ++k)
      if ((A[i] & 1) && is_prime[A[i] + A[k]]) cap[i][k] = 1;
}
int max_flow() {
  memset(vis, false, sizeof(vis));
  int flow = 0;
  while (dfs((N))) {
    ++flow;
    memset(vis, false, sizeof(vis));
  }
  return flow;
}
void dfs2(int cur, vector<int>& ref) {
  if (vis[cur]) return;
  vis[cur] = true;
  ref.push_back(cur + 1);
  for (int nxt : adj[cur]) dfs2(nxt, ref);
}
int main() {
  cin >> N;
  for (int i = 0; i < N; ++i) {
    cin >> A[i];
    if (A[i] & 1)
      ++odds;
    else
      ++evens;
  }
  if (odds != evens) {
    cout << "Impossible\n";
    return 0;
  }
  primes();
  build();
  int flow = max_flow();
  if (flow != N) {
    cout << "Impossible\n";
    return 0;
  }
  for (int i = 0; i < N; ++i)
    for (int k = 0; k < N; ++k)
      if ((A[i] & 1) && is_prime[A[i] + A[k]] && cap[i][k] == 0) {
        adj[i].push_back(k);
        adj[k].push_back(i);
      }
  vector<vector<int>> res;
  memset(vis, false, sizeof(vis));
  for (int i = 0; i < N; ++i)
    if (!vis[i]) {
      res.push_back(vector<int>());
      dfs2(i, res.back());
    }
  cout << res.size() << '\n';
  for (vector<int>& v : res) {
    cout << v.size() << ' ';
    for (int x : v) cout << x << ' ';
    cout << '\n';
  }
  return 0;
}