#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";
    } else {
 
    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);
        cout << "Yes\n";
        for (auto x : sol) {
            cout << x.first << " " << x.second << '\n';
        }
    }
    }
    return 0;
}

Measured memory_bytes: 4436