#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
  int res = 0;
  while (n && ++res) n -= n & (-n);
  return res;
}
vector<int> primes;
vector<bool> iscomposite;
int precalc(int n) {
  primes = vector<int>();
  iscomposite = vector<bool>(n + 1, false);
  for (int i = 2; i <= n; i++) {
    if (!iscomposite[i]) {
      primes.push_back(i);
    }
    for (int j = 0; primes[j] * i < n; j++) {
      iscomposite[primes[j] * i] = true;
      if (i % primes[j] == 0) {
        break;
      }
    }
  }
  return 0;
}
int a[1000006];
int main() {
  precalc(2000001);
  int n;
  cin >> n;
  pair<int, int> ans1 = {0, 0};
  pair<int, int> ans2 = {0, 0};
  vector<int> ansa;
  int cnt = 0;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    if (a[i] == 1) cnt++;
  }
  pair<int, int> sw = {0, 0};
  bool fl = false;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (iscomposite[a[i] + a[j]] == false) {
        fl = true;
        ans1 = {a[i], a[j]};
        if ((ans2 == sw || (a[i] == 1) + (a[j] == 1) <
                               (ans2.first == 1) + (ans2.second == 1)) &&
            !iscomposite[a[i] + 1] && !iscomposite[a[j] + 1]) {
          ans2 = {a[i], a[j]};
        }
      }
    }
  }
  if (!fl) {
    cout << "1\n" << a[0];
    return 0;
  }
  ansa.push_back(ans1.first);
  ansa.push_back(ans1.second);
  if (cnt > 0 && ans2 != sw) {
    ansa.pop_back();
    ansa.pop_back();
    int rem = (ans2.first == 1) + (ans2.second == 1);
    cnt -= rem;
    while (cnt--) ansa.push_back(1);
    ansa.push_back(ans2.first);
    ansa.push_back(ans2.second);
  }
  cout << ansa.size() << "\n";
  for (auto i : ansa) cout << i << " ";
}

### Prompt

Your challenge is to write a CPP solution to the following problem:

A tuple of positive integers {x1, x2, ..., xk} is called simple if for all pairs of positive integers (i, j) (1 ≤ i < j ≤ k), xi + xj is a prime.

You are given an array a with n positive integers a1, a2, ..., an (not necessary distinct). You want to find a simple subset of the array a with the maximum size.

A prime number (or a prime) is a natural number greater than 1 that has no positive divisors other than 1 and itself.

Let's define a subset of the array a as a tuple that can be obtained from a by removing some (possibly all) elements of it.

Input

The first line contains integer n (1 ≤ n ≤ 1000) — the number of integers in the array a.

The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.

Output

On the first line print integer m — the maximum possible size of simple subset of a.

On the second line print m integers bl — the elements of the simple subset of the array a with the maximum size.

If there is more than one solution you can print any of them. You can print the elements of the subset in any order.

Examples

Input

2
2 3


Output

2
3 2


Input

2
2 2


Output

1
2


Input

3
2 1 1


Output

3
1 1 2


Input

2
83 14


Output

2
14 83

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
  int res = 0;
  while (n && ++res) n -= n & (-n);
  return res;
}
vector<int> primes;
vector<bool> iscomposite;
int precalc(int n) {
  primes = vector<int>();
  iscomposite = vector<bool>(n + 1, false);
  for (int i = 2; i <= n; i++) {
    if (!iscomposite[i]) {
      primes.push_back(i);
    }
    for (int j = 0; primes[j] * i < n; j++) {
      iscomposite[primes[j] * i] = true;
      if (i % primes[j] == 0) {
        break;
      }
    }
  }
  return 0;
}
int a[1000006];
int main() {
  precalc(2000001);
  int n;
  cin >> n;
  pair<int, int> ans1 = {0, 0};
  pair<int, int> ans2 = {0, 0};
  vector<int> ansa;
  int cnt = 0;
  for (int i = 0; i < n; i++) {
    cin >> a[i];
    if (a[i] == 1) cnt++;
  }
  pair<int, int> sw = {0, 0};
  bool fl = false;
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (iscomposite[a[i] + a[j]] == false) {
        fl = true;
        ans1 = {a[i], a[j]};
        if ((ans2 == sw || (a[i] == 1) + (a[j] == 1) <
                               (ans2.first == 1) + (ans2.second == 1)) &&
            !iscomposite[a[i] + 1] && !iscomposite[a[j] + 1]) {
          ans2 = {a[i], a[j]};
        }
      }
    }
  }
  if (!fl) {
    cout << "1\n" << a[0];
    return 0;
  }
  ansa.push_back(ans1.first);
  ansa.push_back(ans1.second);
  if (cnt > 0 && ans2 != sw) {
    ansa.pop_back();
    ansa.pop_back();
    int rem = (ans2.first == 1) + (ans2.second == 1);
    cnt -= rem;
    while (cnt--) ansa.push_back(1);
    ansa.push_back(ans2.first);
    ansa.push_back(ans2.second);
  }
  cout << ansa.size() << "\n";
  for (auto i : ansa) cout << i << " ";
}

```