Problem:
Score : 700 points

Problem Statement

You are given an integer N. Determine if there exists a tree with 2N vertices numbered 1 to 2N satisfying the following condition, and show one such tree if the answer is yes.

Assume that, for each integer i between 1 and N (inclusive), Vertex i and N+i have the weight i. Then, for each integer i between 1 and N, the bitwise XOR of the weights of the vertices on the path between Vertex i and N+i (including themselves) is i.

Constraints

N is an integer.

1 \leq N \leq 10^{5}

Input

Input is given from Standard Input in the following format:

N

Output

If there exists a tree satisfying the condition in the statement, print Yes; otherwise, print No.
Then, if such a tree exists, print the 2N-1 edges of such a tree in the subsequent 2N-1 lines, in the following format:

a_{1} b_{1}
\vdots
a_{2N-1} b_{2N-1}

Here each pair (a_i, b_i) means that there is an edge connecting Vertex a_i and b_i. The edges may be printed in any order.

Sample Input 1

3

Sample Output 1

Yes
1 2
2 3
3 4
4 5
5 6

The sample output represents the following graph:

Sample Input 2

1

Sample Output 2

No

There is no tree satisfying the condition.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>

using namespace std;

void Check(int n, vector<pair<int, int>> sol) {
    return;
    assert(sol.size() + 1 == 2 * n);
    
    
    for (int i = 1; i <= n; ++i) {
        vector<int> vis(2 * n + 1, -1);
        auto val = [&](int node) { if (node > n) 
            return node - n; else return node; };  
        vis[i] = val(i);
        while (true) {
            bool ch = false;
            for (auto p : sol) {
                if (vis[p.first] == -1) swap(p.first, p.second);
                if (vis[p.first] == -1 || vis[p.second] != -1) continue;
                vis[p.second] = val(p.second) ^ vis[p.first];
                ch = true;
            }
            if (!ch) break;
        }
        cerr << i << endl;
        cerr << "!!!" << vis[n + i] << endl;
        assert(vis[n + i] == i);
    }
}

int main() {
    int n; cin >> n;
    if (n < 3) {
        cout << "No\n";
        return 0;
    }
    
    int m = 1;
    while (m <= n) m *= 2;
    if (m > n + 1)
        m /= 2;
    assert(m <= n + 1);
    
    if (m == n) {
        cout << "No\n";
        return 0;
    }

    if (n % 2 == 1) {
        cout << "Yes\n";
        
        vector<pair<int, int>> sol;
        for (int i = 1; i + 1 < m; ++i) {
            sol.emplace_back(i, i + 1);
            sol.emplace_back(n + i, n + i + 1);
        }
        sol.emplace_back(m - 1, n + 1);
        
        if (m <= n) {
            int xor_sum = 0;
            for (int i = m; i < n; ++i) {
                sol.emplace_back(i, i + 1);
                sol.emplace_back(i + n, i + n + 1);
                xor_sum ^= i;
            }
            xor_sum ^= n;
            if (xor_sum == 0) {
                sol.emplace_back(n, 1);
                sol.emplace_back(n, m + n);
            } else {
                assert(xor_sum < m);
                sol.emplace_back(n, xor_sum);
                sol.emplace_back(xor_sum, m + n);
            }
        }
        Check(n, sol);
        for (auto x : sol) {
            cout << x.first << " " << x.second << '\n';
        }
    } else {
        vector<pair<int, int>> sol;
        assert(m + 2 <= n);
        sol.emplace_back(m + 2, 2);
        sol.emplace_back(2, m);
        sol.emplace_back(m, m + 1);
        sol.emplace_back(m, 1);
        sol.emplace_back(1, m + n + 1);
        sol.emplace_back(m + n + 1, m + n);
        sol.emplace_back(m + n, m + n + 2);
        sol.emplace_back(m + n, n + 1);
        sol.emplace_back(n + 1, n + 3);
        sol.emplace_back(m + n + 2, n + 2);
        sol.emplace_back(m + n + 2, 3);  

        for (int b = 4, e = 8; e <= m; b *= 2, e *= 2) {
            for (int i = b; i + 1 < e; ++i) {
                sol.emplace_back(i, i + 1);
                sol.emplace_back(i + n, i + n + 1);
            }
            sol.emplace_back(e - 1, b + n);
            sol.emplace_back(b, 1);
        }  

        if (m + 2 < n) {
            int xor_sum = 0;
            for (int i = m + 3; i <= n; ++i)
                xor_sum ^= i;
            
            for (int i = m + 3; i < n; ++i) {
                sol.emplace_back(i, i + 1);
                sol.emplace_back(i + n, i + n + 1);   
            }
            if (xor_sum == 0) {
                sol.emplace_back(n, m + n + 3);
                sol.emplace_back(n, 1);
            } else {
                assert(xor_sum < m);
                sol.emplace_back(n, xor_sum);
                sol.emplace_back(xor_sum, m + n + 3);
            }

        }
        
        Check(n, sol);
        for (auto x : sol) {
            cout << x.first << " " << x.second << '\n';
        }
    }
    return 0;
}