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
/* cerberus97 - Hanit Banga */

#include <iostream>
#include <iomanip>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>

using namespace std;

#define pb push_back
#define fast_cin() ios_base::sync_with_stdio(false); cin.tie(NULL)

typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;

const int N = 1e5 + 10;

int a[N];

vector<int> solve(int n, set<int>& ids, multiset<int>& all_ai);

int main() {
	fast_cin();
	int n; cin >> n;
	set<int> ids;
	multiset<int> all_ai;
	for (int i = 1; i <= n; ++i) {
		cin >> a[i];
		ids.insert(i);
		all_ai.insert(a[i]);
	}
	auto ans = solve(n, ids, all_ai);
	for (auto& i : ans) {
		cout << i << ' ';
	}
	cout << endl;
}

vector<int> solve(int n, set<int>& ids, multiset<int>& all_ai) {
	int cur_banned = 0;
	vector<int> ans;
	for (int i = n; i >= 1; --i) {
		if (i <= 4) {
			vector<int> temp;
			for (auto& id : ids) {
				temp.pb(id);
			}
			do {
				if (cur_banned == temp[0]) {
					continue;
				}
				int sz = temp.size();
				bool ok = true;
				for (int j = 0; j < sz - 1; ++j) {
					if (a[temp[j]] == temp[j + 1]) {
						ok = false;
						break;
					}
				}
				if (ok) {
					for (auto& id : temp) {
						ans.pb(id);
					}
					return ans;
				}
			} while (next_permutation(temp.begin(), temp.end()));
			return {-1};
		} else if (*all_ai.begin() == *prev(all_ai.rbegin()) and ids.count(*all_ai.begin())) {
			int id = *all_ai.begin();
			if (cur_banned == id) {
				return {-1};
			}
			ans.pb(id);
			ids.erase(id);
			all_ai.erase(all_ai.find(a[id]));
			cur_banned = a[id];
		} else if (*next(all_ai.begin()) == *all_ai.rbegin() and ids.count(*all_ai.rbegin())) {
			int id = *all_ai.rbegin();
			if (cur_banned == id) {
				return {-1};
			}
			ans.pb(id);
			ids.erase(id);
			all_ai.erase(all_ai.find(a[id]));
			cur_banned = a[id];
		} else {
			int id = *ids.begin();
			if (cur_banned == id) {
				id = *next(ids.begin());
			}
			ans.pb(id);
			ids.erase(id);
			all_ai.erase(all_ai.find(a[id]));
			cur_banned = a[id];
		}
	}
	return ans;
}
