#include <algorithm> #include <cassert> #include <functional> // Added for std::function #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) { } int num_vertices() { return _n; } void add_edge(int from, int to) { edges.push_back({ from, { to } }); } std::pair<int, std::vector<int>> scc_ids() { auto g = csr<edge>(_n, edges); int now_ord = 0, group_num = 0; std::vector<int> visited, low(_n), ord(_n, -1), ids(_n); visited.reserve(_n); // Use std::function for recursive DFS (C++11 compatible) std::function<void(int)> dfs = [&](int v) -> void { 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++; } }; for (int i = 0; i < _n; i++) { if (ord[i] == -1) { dfs(i); // Call DFS without self-argument } } for (auto& x : ids) { x = group_num - 1 - x; } return std::make_pair(group_num, ids); // C++11-compatible pair construction } std::vector<std::vector<int>> scc() { auto ids = scc_ids(); int group_num = ids.first; std::vector<int> counts(group_num); for (auto x : ids.second) counts[x]++; std::vector<std::vector<int>> groups(ids.first); for (int i = 0; i < group_num; i++) { groups[i].reserve(counts[i]); } for (int i = 0; i < _n; i++) { groups[ids.second[i]].push_back(i); } return groups; } private: int _n; struct edge { int to; }; std::vector<std::pair<int, edge>> edges; }; } // 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; }