Vitya has learned that the answer for The Ultimate Question of Life, the Universe, and Everything is not the integer 54 42, but an increasing integer sequence a_1, …, a_n. In order to not reveal the secret earlier than needed, Vitya encrypted the answer and obtained the sequence b_1, …, b_n using the following rules:

  * b_1 = a_1;
  * b_i = a_i ⊕ a_{i - 1} for all i from 2 to n, where x ⊕ y is the [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of x and y. 



It is easy to see that the original sequence can be obtained using the rule a_i = b_1 ⊕ … ⊕ b_i.

However, some time later Vitya discovered that the integers b_i in the cypher got shuffled, and it can happen that when decrypted using the rule mentioned above, it can produce a sequence that is not increasing. In order to save his reputation in the scientific community, Vasya decided to find some permutation of integers b_i so that the sequence a_i = b_1 ⊕ … ⊕ b_i is strictly increasing. Help him find such a permutation or determine that it is impossible.

Input

The first line contains a single integer n (1 ≤ n ≤ 10^5).

The second line contains n integers b_1, …, b_n (1 ≤ b_i < 2^{60}).

Output

If there are no valid permutations, print a single line containing "No".

Otherwise in the first line print the word "Yes", and in the second line print integers b'_1, …, b'_n — a valid permutation of integers b_i. The unordered multisets \\{b_1, …, b_n\} and \\{b'_1, …, b'_n\} should be equal, i. e. for each integer x the number of occurrences of x in the first multiset should be equal to the number of occurrences of x in the second multiset. Apart from this, the sequence a_i = b'_1 ⊕ … ⊕ b'_i should be strictly increasing.

If there are multiple answers, print any of them.

Examples

Input

3
1 2 3


Output

No


Input

6
4 7 7 12 31 61


Output

Yes
4 12 7 31 7 61 

Note

In the first example no permutation is valid.

In the second example the given answer lead to the sequence a_1 = 4, a_2 = 8, a_3 = 15, a_4 = 16, a_5 = 23, a_6 = 42.
#include <bits/stdc++.h>
using namespace std;
class Trie {
 public:
  Trie(int d = 0) : root(-1), depth(d) { reset(); }
  void reset() {
    root = 0;
    nodes.clear();
    nodes.push_back(Node());
  }
  void add(const string& s) {
    int n = s.length();
    int cur = root;
    for (int i = 0; i <= n; ++i) {
      ++nodes[cur].cnt;
      if (i == n) {
        break;
      }
      if (s[i] == '0') {
        if (nodes[cur].l == -1) {
          nodes[cur].l = nodes.size();
          nodes.push_back(Node());
        }
        cur = nodes[cur].l;
      } else {
        if (nodes[cur].r == -1) {
          nodes[cur].r = nodes.size();
          nodes.push_back(Node());
        }
        cur = nodes[cur].r;
      }
    }
  }
  void remove(const string& s) {
    int n = s.length();
    int cur = root;
    vector<int> path;
    path.push_back(cur);
    for (int i = 0; i < n; ++i) {
      if (s[i] == '0') {
        if (nodes[cur].l == -1) {
          return;
        }
        cur = nodes[cur].l;
      } else {
        if (nodes[cur].r == -1) {
          return;
        }
        cur = nodes[cur].r;
      }
      path.push_back(cur);
    }
    for (auto i : path) {
      --nodes[i].cnt;
    }
  }
  int find(const string& s) {
    int n = s.length();
    int cur = root;
    for (int i = 0; i <= n; ++i) {
      if (nodes[cur].cnt <= 0) {
        return -1;
      }
      if (i == n) {
        break;
      }
      if (s[i] == '0') {
        if (nodes[cur].l == -1) {
          return -1;
        }
        cur = nodes[cur].l;
      } else {
        if (nodes[cur].r == -1) {
          return -1;
        }
        cur = nodes[cur].r;
      }
    }
    return cur;
  }
  string findMaxWith(const string& prefix, const string& suffix) {
    string res;
    int cur = find(prefix);
    if (cur == -1) {
      return "";
    }
    int n = suffix.size();
    int i = 0;
    while (cur != -1 && i < n) {
      if (suffix[i] == '0') {
        if (nodes[cur].r != -1 && nodes[nodes[cur].r].cnt > 0) {
          cur = nodes[cur].r;
          res += "1";
        } else if (nodes[cur].l != -1 && nodes[nodes[cur].l].cnt > 0) {
          cur = nodes[cur].l;
          res += "0";
        } else {
          return "";
        }
      } else {
        if (nodes[cur].l != -1 && nodes[nodes[cur].l].cnt > 0) {
          cur = nodes[cur].l;
          res += "0";
        } else if (nodes[cur].r != -1 && nodes[nodes[cur].r].cnt > 0) {
          cur = nodes[cur].r;
          res += "1";
        } else {
          return "";
        }
      }
      ++i;
    }
    return prefix + res;
  }

 private:
  struct Node {
    Node() : l(-1), r(-1), cnt(0) {}
    int l;
    int r;
    int cnt;
  };
  int root;
  int depth;
  vector<Node> nodes;
};
class Solution {
 public:
  vector<long long> decypt(vector<long long>& nums) {
    Trie tr;
    long long maxNum = 0;
    for (auto num : nums) {
      maxNum ^= num;
    }
    int cnt = 0;
    for (auto num : nums) {
      if (num > maxNum) {
        ++cnt;
      }
    }
    if (cnt == nums.size()) {
      return {};
    }
    cnt = 0;
    for (auto num : nums) {
      if (num == 0) {
        ++cnt;
      }
    }
    if (cnt > 1) {
      return {};
    }
    int len = 0;
    for (int i = 60; i >= 0; --i) {
      if (maxNum & 1LL << i) {
        len = i + 1;
        break;
      }
    }
    for (auto num : nums) {
      string s = toBinary(num);
      tr.add(s.substr(s.length() - len, len));
    }
    int n = nums.size();
    vector<long long> res;
    for (int i = 0; i < n; ++i) {
      string s = toBinary(maxNum);
      bool found = false;
      for (int j = 0; j < len; ++j) {
        if (maxNum & 1LL << j) {
          string prefix = string(len - 1 - j, '0');
          prefix += "1";
          string suffix = s.substr(s.length() - j, j);
          string t = tr.findMaxWith(prefix, suffix);
          if (t.empty()) {
            continue;
          }
          long long num = toLonglong(t);
          if ((maxNum ^ num) >= maxNum) {
            continue;
          }
          maxNum ^= num;
          res.push_back(num);
          tr.remove(t);
          found = true;
          break;
        }
      }
      if (!found) {
        return {};
      }
    }
    reverse(res.begin(), res.end());
    return res;
  }

 private:
  string toBinary(long long num) {
    bitset<62> bits(num);
    return bits.to_string();
  }
  long long toLonglong(const string& s) {
    bitset<62> bits(s);
    return bits.to_ullong();
  }
  bool check(vector<long long>& nums) {
    vector<long long> a;
    if (nums.empty()) {
      return true;
    }
    a.push_back(0);
    int n = nums.size();
    for (int i = 0; i < n; ++i) {
      a.push_back(a.back() ^ nums[i]);
    }
    for (int i = 1; i < a.size(); ++i) {
      cout << a[i] << " ";
    }
    cout << endl;
    for (int i = 2; i < a.size(); ++i) {
      if (a[i] <= a[i - 1]) {
        return false;
      }
    }
    return true;
  }
};
int main(int argc, char** argv) {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  int n;
  cin >> n;
  vector<long long> nums;
  while (n-- > 0) {
    long long num;
    cin >> num;
    nums.push_back(num);
  }
  Solution sol;
  vector<long long> res = sol.decypt(nums);
  if (res.empty()) {
    cout << "No" << endl;
  } else {
    cout << "Yes" << endl;
    for (auto num : res) {
      cout << num << " ";
    }
    cout << endl;
  }
  return 0;
}
