#pragma GCC optimize("Ofast,no-stack-protector") #include <algorithm> #include <cassert> #include <utility> #include <vector> namespace atcoder { namespace internal { template <class E> struct csr { std::vector<int> start; std::vector<E> elist; explicit csr(int n, const std::vector<std::pair<int, E>>& edges) : start(n + 1) , elist(edges.size()) { for (auto e : edges) { start[e.first + 1]++; } for (int i = 1; i <= n; i++) { start[i] += start[i - 1]; } auto counter = start; for (auto e : edges) { elist[counter[e.first]++] = e.second; } } }; } // namespace internal } // namespace atcoder namespace atcoder { namespace internal { struct scc_graph { public: explicit scc_graph(int n) : _n(n) , g(0, {}) { } int num_vertices() { return _n; } void add_edge(int from, int to) { edges.push_back({ from, { to } }); } void scc_ids() { g = csr<edge>(_n, edges); low.resize(_n); ord.resize(_n, -1); ids.resize(_n); visited.reserve(_n); for (int i = 0; i < _n; i++) { if (ord[i] == -1) { dfs(i); } } for (auto& x : ids) { x = group_num - 1 - x; } } std::vector<std::vector<int>> scc() { scc_ids(); std::vector<int> counts(group_num); for (auto x : ids) counts[x]++; std::vector<std::vector<int>> groups(group_num); for (int i = 0; i < group_num; i++) { groups[i].reserve(counts[i]); } for (int i = 0; i < _n; i++) { groups[ids[i]].push_back(i); } return groups; } private: int _n, now_ord = 0, group_num = 0; struct edge { int to; }; std::vector<int> visited, low, ord, ids; std::vector<std::pair<int, edge>> edges; csr<edge> g; void dfs(int v) { low[v] = ord[v] = now_ord++; visited.push_back(v); for (int i = g.start[v]; i < g.start[v + 1]; i++) { auto to = g.elist[i].to; if (ord[to] == -1) { dfs(to); // Recursive call low[v] = std::min(low[v], low[to]); } else { low[v] = std::min(low[v], ord[to]); } } if (low[v] == ord[v]) { while (true) { int u = visited.back(); visited.pop_back(); ord[u] = _n; ids[u] = group_num; if (u == v) break; } group_num++; } } }; } // namespace internal } // namespace atcoder namespace atcoder { struct scc_graph { public: scc_graph() : internal(0) { } explicit scc_graph(int n) : internal(n) { } void add_edge(int from, int to) { int n = internal.num_vertices(); assert(0 <= from && from < n); assert(0 <= to && to < n); internal.add_edge(from, to); } std::vector<std::vector<int>> scc() { return internal.scc(); } private: internal::scc_graph internal; }; } // namespace atcoder #include <iostream> using namespace std; using i64 = long long; constexpr int V = 1 << 20; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int n; cin >> n; vector<int> A(n); atcoder::scc_graph graph(V + n); for (auto& a : A) cin >> a; for (int i = 1; i < V; ++i) { for (int cur = i; cur > 0; cur -= cur & -cur) graph.add_edge(i, i ^ (cur & -cur)); } for (int i = 0; i < n; ++i) { graph.add_edge(i + V, V - 1 - A[i]); graph.add_edge(V - 1 - A[i], i + V); graph.add_edge(A[i], i + V); } vector<int> ans(n); for (const auto& group : graph.scc()) { vector<int> pos, cur; pos.reserve(group.size()); cur.reserve(group.size()); for (auto i : group) { if (i < V) continue; else i -= V; cur.push_back(A[i]); pos.push_back(i); } sort(cur.begin(), cur.end()); for (int i = 0, m = pos.size(); i < m; ++i) ans[pos[i]] = cur[i]; } for (auto a : ans) cout << a << ' '; return 0; }