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>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e5 + 3, M = 1e5 + 3, BIG = 1e9 + 3, MOD = 1e9 + 7,
          P = 'z' - 'a' + 1;
const double PI = 3.14159265359;
struct input {
  int fr, to, c;
};
struct Edge {
  int to, w, c;
  Edge *rev;
  Edge() { rev = nullptr; }
  Edge(int t, int ww, int cc) { to = t, w = ww, c = cc, rev = nullptr; }
};
int n, m, st, fin;
vector<vector<Edge *>> gr;
vector<bool> used, prime;
int dfs(int v, int d) {
  if (d == 0) return 0;
  if (v == fin) return d;
  used[v] = true;
  for (auto &to : gr[v]) {
    if (used[to->to]) continue;
    int d2 = dfs(to->to, min(d, to->c - to->w));
    if (d2 > 0) {
      to->w += d2;
      to->rev->w -= d2;
      return d2;
    }
  }
  return 0;
}
void out_gr(vector<int> a = vector<int>(n)) {
  for (int i = 0; i < gr.size(); ++i) {
    if (i - 1 >= 0 && i - 1 < a.size()) cout << a[i - 1] << " : ";
    vector<Edge *> v = gr[i];
    for (auto &x : v) cout << x->to << " " << x->w << " " << x->c << ", ";
    cout << "\n";
  }
  cout << endl;
}
void new_edge(int fr, int to, int c) {
  gr[fr].push_back(new Edge(to, 0, c));
  gr[to].push_back(new Edge(fr, 0, 0));
  gr[fr].back()->rev = gr[to].back();
  gr[to].back()->rev = gr[fr].back();
}
void dfs2(int v, vector<int> &ans) {
  used[v] = true;
  ans.push_back(v);
  for (auto &to : gr[v]) {
    if (used[to->to]) continue;
    if (abs(to->w) == 1) dfs2(to->to, ans);
  }
}
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  prime.resize(N, true);
  for (int i = 2; i < N; ++i) {
    if (!prime[i]) continue;
    for (int j = i * 2; j < N; j += i) prime[j] = false;
  }
  cin >> n;
  vector<int> a(n);
  vector<pair<int, int>> even, odd;
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
    if (a[i] % 2 == 0)
      even.push_back({a[i], i});
    else
      odd.push_back({a[i], i});
  }
  if (even.size() != odd.size()) {
    cout << "Impossible";
    return 0;
  }
  gr.resize(n + 2);
  st = 0;
  fin = n + 1;
  for (auto &p : odd) {
    new_edge(st, 1 + p.second, 2);
  }
  for (auto &p : even) {
    new_edge(1 + p.second, fin, 2);
  }
  for (auto &p1 : odd)
    for (auto &p2 : even)
      if (prime[p1.first + p2.first]) {
        new_edge(1 + p1.second, 1 + p2.second, 1);
      }
  for (int i = 0; i < n * 4; ++i) {
    used.clear();
    used.resize(n + 2);
    if (dfs(0, BIG) == 0) break;
  }
  int sum = 0;
  for (auto &to : gr[st]) sum += to->w;
  if (sum != n) {
    cout << "Impossible";
    return 0;
  }
  vector<vector<int>> ans;
  for (int i = 1; i <= even.size(); ++i)
    if (!used[i]) {
      vector<int> ans_v;
      dfs2(i, ans_v);
      ans.push_back(ans_v);
    }
  cout << ans.size() << "\n";
  for (auto &v : ans) {
    cout << v.size() << "  ";
    for (auto &x : v) cout << x << " ";
    cout << "\n";
  }
  return 0;
}
