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 nmax = 205;
const int inf = 1 << 30;
int n, i, j, x, A, B, add, source, sink, sol, cnt;
int cap[nmax][nmax], flow[nmax][nmax];
int a[nmax], f[nmax];
vector<int> v[nmax], V[nmax], S[nmax];
queue<int> q;
bitset<nmax> viz;
bool prime(int x) {
  for (int i = 2; i * i <= x; i++)
    if (x % i == 0) return 0;
  return 1;
}
bool bfs(int source) {
  memset(f, -1, sizeof(f));
  f[source] = source;
  q.push(source);
  while (!q.empty()) {
    x = q.front();
    q.pop();
    if (x == sink) continue;
    for (auto it : v[x])
      if (f[it] == -1 && flow[x][it] < cap[x][it]) {
        f[it] = x;
        q.push(it);
      }
  }
  return f[sink] != -1;
}
void dfs(int x) {
  viz[x] = 1;
  S[cnt].push_back(x);
  for (auto it : V[x])
    if (!viz[it]) dfs(it);
}
int main() {
  cin.sync_with_stdio(false);
  cin >> n;
  for (i = 1; i <= n; i++) cin >> a[i];
  for (i = 1; i <= n; i++) {
    if (a[i] & 1) {
      A++;
      v[0].push_back(i);
      v[i].push_back(0);
      cap[0][i] = 2;
    } else {
      B++;
      v[i].push_back(n + 1);
      v[n + 1].push_back(i);
      cap[i][n + 1] = 2;
    }
  }
  if (A != B) {
    cout << "Impossible\n";
    return 0;
  }
  for (i = 1; i <= n; i++)
    for (j = 1; j <= n; j++)
      if ((a[i] & 1) && !(a[j] & 1) && prime(a[i] + a[j])) {
        v[i].push_back(j);
        v[j].push_back(i);
        cap[i][j] = 1;
      }
  source = 0;
  sink = n + 1;
  while (bfs(source)) {
    for (auto it : v[sink])
      if (f[it] != -1) {
        f[sink] = it;
        add = inf;
        for (x = sink; f[x] != x; x = f[x])
          add = min(add, cap[f[x]][x] - flow[f[x]][x]);
        for (x = sink; f[x] != x; x = f[x]) {
          flow[f[x]][x] += add;
          flow[x][f[x]] -= add;
        }
        sol += add;
      }
  }
  if (sol != n) {
    cout << "Impossible\n";
    return 0;
  }
  for (i = 1; i <= n; i++)
    for (j = 1; j <= n; j++)
      if (cap[i][j] == 1 && flow[i][j] == 1) {
        V[i].push_back(j);
        V[j].push_back(i);
      }
  for (i = 1; i <= n; i++)
    if (!viz[i]) {
      cnt++;
      dfs(i);
    }
  cout << cnt << '\n';
  for (i = 1; i <= cnt; i++) {
    cout << S[i].size() << " ";
    for (auto it : S[i]) cout << it << " ";
    cout << '\n';
  }
  return 0;
}