Niwango has N cards, numbered 1,2,\ldots,N. He will now arrange these cards in a row.

Niwango wants to know if there is a way to arrange the cards while satisfying all the N conditions below. To help him, determine whether such a way exists. If the answer is yes, also find the lexicographically smallest such arrangement.

* To the immediate right of Card 1 (if any) is NOT Card a_1.
* To the immediate right of Card 2 (if any) is NOT Card a_2.
* \vdots
* To the immediate right of Card N (if any) is NOT Card a_N.

Constraints

* 2 \leq N \leq 10^{5}
* 1 \leq a_i \leq N
* a_i \neq i

Input

Input is given from Standard Input in the following format:


N
a_1 a_2 \ldots a_N


Output

If no arrangements satisfy the conditions, print `-1`. If such arrangements exist, print the lexicographically smallest such arrangement, in the following format:


b_1 b_2 \ldots b_N


Here, b_i represents the i-th card from the left.

Examples

Input

4
2 3 4 1


Output

1 3 2 4


Input

2
2 1


Output

-1


Input

13
2 3 4 5 6 7 8 9 10 11 12 13 12


Output

1 3 2 4 6 5 7 9 8 10 12 11 13
#include <bits/stdc++.h>

using namespace std;


void solve() {
    int n; cin >> n;
    vector<int> a(n), indeg(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        a[i]--;
        indeg[a[i]]++;
    }
    if (n == 2) {
        cout << -1; return;
    }
    set<int> bucket;
    set<pair<int,int>> lookup;
    for (int i = 0; i < n; i++) {
        bucket.insert(i);
        lookup.insert({indeg[i], i});
    }
    vector<int> p(n);
    vector<bool> trk(n);
    const int L = 3; 
    for (int i = 0; i < n-L; i++) {
        auto it = --lookup.end();
        int cnt,z;
        tie(cnt,z) = *it;
        for (int x: bucket) {
            if (i == 0 || a[p[i-1]] != x) {
                if (z == x || cnt - (i && a[p[i-1]]==z) < n-i-1) {
                    p[i] = x;
                    break;
                }
            }
        }
        if (i > 0) {
            int x = a[p[i-1]];
            if (!trk[x]) {
                lookup.erase({indeg[x],x});
                lookup.insert({--indeg[x], x});
            }
        }
        trk[p[i]] = true;
        bucket.erase(p[i]);
        lookup.erase({indeg[p[i]], p[i]});
    }

    for (int i = max(0, n-L); i < n; i++) {
        p[i] = *bucket.begin();
        bucket.erase(p[i]);
    }
    do {
        bool yes = true;
        for (int i = max(1, n-L); i < n; i++) {
            if (a[p[i-1]] == p[i]) yes = false;
        }
        if (yes) {
            for (int x: p) cout << x+1 << ' ';
            return;
        }
    } while (next_permutation(p.begin(), p.end()));
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    solve();
    cout << endl;
}
