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;
bool debug;
const int inf = 1e9 + 5;
const int nax = 1e3 + 5;
namespace Flow {
int odl[nax], q[nax];
int m[nax][nax];
vector<int>::iterator pocz[nax];
vector<int> v[nax];
void init(int n) {
  for (int i = 0; i <= n; ++i) v[i].clear();
  for (int i = 0; i <= n; ++i)
    for (int j = 0; j <= n; ++j) m[i][j] = 0;
}
void AddEdge(int a, int b, int c) {
  v[a].push_back(b);
  v[b].push_back(a);
  m[a][b] += c;
}
bool bst(int s, int t, int n) {
  for (int i = 0; i <= n; ++i) odl[i] = inf;
  odl[s] = 0;
  int qbeg = 0, qend = 0;
  q[qend++] = s;
  while (qbeg < qend) {
    int x = q[qbeg++];
    for (auto j : v[x])
      if (m[x][j] > 0 && odl[j] == inf) {
        odl[j] = odl[x] + 1;
        q[qend++] = j;
      }
  }
  return odl[t] != inf;
}
int flow(int x, int t, int maximum) {
  if (x == t || maximum == 0) return maximum;
  int res = 0;
  for (vector<int>::iterator &it = pocz[x]; it != v[x].end(); it++)
    if (m[x][*it] > 0 && odl[*it] == odl[x] + 1) {
      int y = flow(*it, t, min(maximum, m[x][*it]));
      maximum -= y;
      m[x][*it] -= y;
      m[*it][x] += y;
      res += y;
      if (maximum == 0) return res;
    }
  return res;
}
int MaxFlow(int s, int t, int n) {
  int res = 0;
  while (bst(s, t, n)) {
    for (int i = 0; i <= n; ++i) pocz[i] = v[i].begin();
    res += flow(s, t, inf);
  }
  return res;
}
}  // namespace Flow
bool pier(int x) {
  for (int i = 2; i * i <= x; i++)
    if (x % i == 0) return false;
  return true;
}
int n, m, c, d, ile;
int a[nax], pocz[nax];
vector<int> stul[nax], wyn[nax];
bool bylo[nax];
vector<pair<int, int> > fac[nax];
void dfs(int x) {
  bylo[x] = true;
  wyn[ile].push_back(x);
  for (auto j : stul[x])
    if (!bylo[j]) dfs(j);
}
int main(int argc, char *argv[]) {
  debug = argc > 1;
  scanf("%d", &n);
  Flow::init(n + 1);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", &a[i]);
    if (a[i] & 1)
      Flow::AddEdge(0, i, 2);
    else
      Flow::AddEdge(i, n + 1, 2);
  }
  for (int i = 1; i <= n; ++i)
    if (a[i] & 1)
      for (int j = 1; j <= n; ++j)
        if (pier(a[i] + a[j])) Flow::AddEdge(i, j, 1);
  if (Flow::MaxFlow(0, n + 1, n + 1) == n) {
    for (int j = 1; j <= n; ++j)
      if (!(a[j] & 1))
        for (int i = 1; i <= n; ++i)
          if (Flow::m[j][i] == 1) {
            stul[i].push_back(j);
            stul[j].push_back(i);
          }
    for (int i = 1; i <= n; ++i)
      if (!bylo[i]) {
        dfs(i);
        ++ile;
      }
    printf("%d\n", ile);
    for (int i = 0; i <= (ile)-1; ++i) {
      printf("%d", (int)wyn[i].size());
      for (auto j : wyn[i]) printf(" %d", j);
      puts("");
    }
  } else {
    puts("Impossible");
  }
  return 0;
}
