#include <bits/stdc++.h>
struct IsPrime {
  std::vector<int> primes;
  IsPrime() : primes{2} {}
  auto operator()(int prime) -> bool;
};
auto main() -> int {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  size_t count;
  std::cin >> count;
  std::vector<int> array(count);
  for (auto &elem : array) {
    std::cin >> elem;
  }
  auto is_prime = IsPrime();
  std::vector<int> two_and_one;
  for (auto elem : array) {
    if (elem == 1) {
      two_and_one.push_back(elem);
    }
  }
  for (auto elem : array) {
    if (is_prime(elem + 1) && elem != 1) {
      two_and_one.push_back(elem);
      break;
    }
  }
  if (two_and_one.size() > 2) {
    std::cout << two_and_one.size() << '\n';
    for (auto elem : two_and_one) {
      std::cout << ' ' << elem;
    }
    return 0;
  }
  for (size_t i = 0; i < count; ++i) {
    for (size_t j = i + 1; j < count; ++j) {
      if (is_prime(array[i] + array[j])) {
        std::cout << 2 << '\n' << array[i] << ' ' << array[j] << '\n';
        return 0;
      }
    }
  }
  if (two_and_one.size() > 1) {
    std::cout << two_and_one.size() << '\n';
    for (auto elem : two_and_one) {
      std::cout << ' ' << elem;
    }
    return 0;
  }
  for (auto p : array) {
    std::cout << 1 << '\n' << p;
    return 0;
  }
  std::cout << 0 << '\n';
  return 0;
}
auto IsPrime::operator()(int prime) -> bool {
  for (auto p = primes.back() + 1; p <= prime; ++p) {
    bool is_prime = true;
    for (auto p1 : primes) {
      if (p1 * p1 > p) {
        break;
      }
      if (p % p1 == 0) {
        is_prime = false;
        break;
      }
    }
    if (is_prime) {
      primes.push_back(p);
    }
  }
  return std::binary_search(primes.begin(), primes.end(), prime);
}

### Prompt

Construct a CPP code solution to the problem outlined:

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>
struct IsPrime {
  std::vector<int> primes;
  IsPrime() : primes{2} {}
  auto operator()(int prime) -> bool;
};
auto main() -> int {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  size_t count;
  std::cin >> count;
  std::vector<int> array(count);
  for (auto &elem : array) {
    std::cin >> elem;
  }
  auto is_prime = IsPrime();
  std::vector<int> two_and_one;
  for (auto elem : array) {
    if (elem == 1) {
      two_and_one.push_back(elem);
    }
  }
  for (auto elem : array) {
    if (is_prime(elem + 1) && elem != 1) {
      two_and_one.push_back(elem);
      break;
    }
  }
  if (two_and_one.size() > 2) {
    std::cout << two_and_one.size() << '\n';
    for (auto elem : two_and_one) {
      std::cout << ' ' << elem;
    }
    return 0;
  }
  for (size_t i = 0; i < count; ++i) {
    for (size_t j = i + 1; j < count; ++j) {
      if (is_prime(array[i] + array[j])) {
        std::cout << 2 << '\n' << array[i] << ' ' << array[j] << '\n';
        return 0;
      }
    }
  }
  if (two_and_one.size() > 1) {
    std::cout << two_and_one.size() << '\n';
    for (auto elem : two_and_one) {
      std::cout << ' ' << elem;
    }
    return 0;
  }
  for (auto p : array) {
    std::cout << 1 << '\n' << p;
    return 0;
  }
  std::cout << 0 << '\n';
  return 0;
}
auto IsPrime::operator()(int prime) -> bool {
  for (auto p = primes.back() + 1; p <= prime; ++p) {
    bool is_prime = true;
    for (auto p1 : primes) {
      if (p1 * p1 > p) {
        break;
      }
      if (p % p1 == 0) {
        is_prime = false;
        break;
      }
    }
    if (is_prime) {
      primes.push_back(p);
    }
  }
  return std::binary_search(primes.begin(), primes.end(), prime);
}

```