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.
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210, MAX = 0x7f7f7f7f;
int N, cA, cB;
int nm[maxn];
int A[maxn], B[maxn];
int vi[maxn], cnt, vi2[maxn], cnt2;
struct Edge {
  int to, cap;
  Edge *next, *oppo;
};
Edge *E[maxn], Pr[maxn * maxn << 1];
int Es;
void addedge(int u, int v, int cap) {
  Pr[++Es].to = v;
  Pr[Es].cap = cap;
  Pr[Es].oppo = &Pr[Es + 1];
  Pr[Es].next = E[u];
  E[u] = &Pr[Es];
  Pr[++Es].to = u;
  Pr[Es].cap = 0;
  Pr[Es].oppo = &Pr[Es - 1];
  Pr[Es].next = E[v];
  E[v] = &Pr[Es];
}
int s, t;
int H[maxn];
queue<int> Q;
bool Makelevel() {
  memset(H, 127, sizeof(H));
  H[s] = 0;
  Q.push(s);
  while (!Q.empty()) {
    int u = Q.front();
    Q.pop();
    for (Edge *P = E[u]; P; P = P->next)
      if (P->cap && H[P->to] > H[u] + 1) {
        H[P->to] = H[u] + 1;
        Q.push(P->to);
      }
  }
  return H[t] < MAX;
}
int extend(int u, int res) {
  int s = 0;
  if (u == t) return res;
  for (Edge *P = E[u]; P && s < res; P = P->next)
    if (P->cap && H[P->to] == H[u] + 1) {
      int t;
      t = extend(P->to, min(res - s, P->cap));
      s += t;
      P->cap -= t;
      P->oppo->cap += t;
    }
  if (!s) H[u] = MAX;
  return s;
}
int MaxFlow() {
  int ans = 0;
  while (Makelevel()) ans += extend(s, MAX);
  return ans;
}
int Ans[maxn], Anscnt;
void dfs(int u) {
  vi[u] = cnt;
  for (Edge *P = E[u]; P; P = P->next)
    if (!vi[P->to])
      if (((nm[u] & 1) && !P->cap) || (!(nm[u] & 1) && !P->oppo->cap))
        dfs(P->to);
}
void dfs2(int u) {
  Ans[++Anscnt] = u;
  vi2[u] = cnt2;
  for (Edge *P = E[u]; P; P = P->next)
    if (!vi2[P->to])
      if (((nm[u] & 1) && !P->cap) || (!(nm[u] & 1) && !P->oppo->cap))
        dfs2(P->to);
}
void Work() {
  if (cA != cB || MaxFlow() != cA * 2) {
    puts("Impossible");
    return;
  }
  for (int i = 1; i <= N; i++)
    if (!vi[i]) cnt++, dfs(i);
  printf("%d\n", cnt);
  for (int i = 1; i <= cnt; i++) {
    int tot = 0;
    for (int j = 1; j <= N; j++)
      if (vi[j] == i) tot++;
    printf("%d", tot);
    Anscnt = 0;
    cnt2++;
    for (int j = 1; j <= N; j++)
      if (vi[j] == i) {
        dfs2(j);
        break;
      }
    for (int j = 1; j <= Anscnt; j++) printf(" %d", Ans[j]);
    printf("\n");
  }
}
bool check(int n) {
  for (int i = 2; i <= n / i; i++)
    if (n % i == 0) return false;
  return true;
}
void Init() {
  scanf("%d", &N);
  for (int i = 1; i <= N; i++) {
    scanf("%d", &nm[i]);
    if (nm[i] & 1)
      A[++cA] = i;
    else
      B[++cB] = i;
  }
  s = 0;
  t = N + 1;
  for (int i = 1; i <= cA; i++) addedge(s, A[i], 2);
  for (int i = 1; i <= cB; i++) addedge(B[i], t, 2);
  for (int i = 1; i <= cA; i++)
    for (int j = 1; j <= cB; j++)
      if (check(nm[A[i]] + nm[B[j]])) addedge(A[i], B[j], 1);
}
int main() {
  Init();
  Work();
  return 0;
}
