/<> 1017 (maximum bipartite matching)

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <unordered_map>
#include <numeric>
#include <iomanip>
using namespace std;
#define pii pair<int , int>
#define ll long long
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL)
const long long dx[4] = {1, 0, -1, 0}, dy[4] = {0, -1, 0, 1};
const long long dl[2] = {1, -1};
const long long MOD = 1000000007;
const long long MAXN = 55;

vector<int> primes;
int n;
int arr[55];
int idx[2005];
vector<int> v[55];
vector<int> g1, g2;
vector<int> connected;
vector<bool> visited;

void init_prime(){
    for(int i = 2; i <= 2000; i++){
        bool ck = true;
        for(int j = 2; j <= sqrt(i); j++){
            if(i % j == 0){
                ck = false;
                break;
            }
        }
        if(ck){
            primes.push_back(i);
        }
    }
}

void init(){
    init_prime();
    for(int i = 0; i <= 2000; i++){
        idx[i] = -1;
    }
    for(int i = 0; i < n; i++){
        cin >> arr[i];
        idx[arr[i]] = i;
        if(arr[i] % 2 == arr[0] % 2){
            g1.push_back(i);
        }
        else{
            g2.push_back(i);
        }
    }
    for(int i = 0; i < n; i++){
        for(auto p : primes){
            if(p < arr[i]){
                continue;
            }
            else{
                if(idx[p - arr[i]] != -1 and idx[p - arr[i]] != i){
                    v[i].push_back(idx[p - arr[i]]);
                }
            }
        }
    }
}

bool dfs(int c, int x){
    if(visited[c]){
        return false;
    }
    visited[c] = true;
    if(c == 0){
        if(connected[x] == -1 || dfs(connected[x], x)){
            connected[x] = c;
            return true;
        }
        return false;
    }
    for(int nxt : v[c]){
        if(connected[nxt] == -1 || dfs(connected[nxt], x)){
            connected[nxt] = c;
            return true;
        }
    }
    return false;

}

void solve(){
    if(g1.size() != g2.size()){
        cout << "-1\n";
        return;
    }
    vector<int> ans;
    for(auto x : v[0]){
        connected.assign(n, -1);
        for(auto c1 : g1){
            visited.assign(n, false);
            dfs(c1, x);
        }
        bool ck = true;
        int tmp = 0;
        for (int i = 0; i < g2.size(); i++){
            if(connected[g2[i]] == -1){
                ck = false;
                break;
            }
            if(connected[g2[i]] == 0){
                tmp = arr[g2[i]];
            }
        }
        if(ck){
            ans.push_back(tmp);
        }
    }

    if(ans.size() == 0){
        cout << "-1\n";
        return;
    }
    else{
        sort(ans.begin(), ans.end());
        for(auto x : ans){
            cout << x << " ";
        }
        return;
    }
}

int main() {
    FAST;
    cin >> n;
    init();
    solve();
}