#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// https://oeis.org/A000081
constexpr int UNLABELED_ROOTED[26] = {0, 1, 1, 2, 4, 9, 20, 48, 115, 286, 719, 1842, 4766, 12486, 32973, 87811, 235381, 634847, 1721159, 4688676, 12826228, 35221832, 97055181, 268282855, 743724984, 2067174645};
// https://oeis.org/A000055
constexpr int UNLABELED_UNROOTED[29] = {0, 1, 1, 1, 2, 3, 6, 11, 23, 47, 106, 235, 551, 1301, 3159, 7741, 19320, 48629, 123867, 317955, 823065, 2144505, 5623756, 14828074, 39299897, 104636890, 279793450, 751065460, 2023443032};

namespace enu_tree {
constexpr int MAX_N = 21;

using Id = pair<int, int>;

// (largest subtree, remaining tree)
vector<pair<Id, Id>> T[MAX_N + 1];

inline int TLen(int n) {
  return T[n].size();
}

// tie-break (n/2) + (n/2)
inline bool isCentroid(int n, int x) {
  return (T[n][x].first <= T[n][x].second);
}

// |non-root subtree| <= limDn
void build(int limDn = MAX_N - 1) {
  for (int n = 0; n <= MAX_N; ++n) T[n].clear();
  T[1].emplace_back(Id(0, 0), Id(0, 0));
  for (int dn = 1; dn < MAX_N && dn <= limDn; ++dn) for (int dx = 0; dx < TLen(dn); ++dx) {
    for (int n = 1; n + dn <= MAX_N; ++n) for (int x = 0; x < TLen(n); ++x) {
      T[n + dn].emplace_back(Id(dn, dx), Id(n, x));
    }
  }
}

void getParDfs(int n, int x, int p, int &id, vector<int> &par) {
  const int u = id++;
  par[u] = p;
  for (int nn = n, xx = x; nn > 1; ) {
    const auto &t = T[nn][xx];
    getParDfs(t.first.first, t.first.second, u, id, par);
    nn = t.second.first;
    xx = t.second.second;
  }
}
vector<int> getPar(int n, int x) {
  assert(1 <= n); assert(n <= MAX_N);
  assert(0 <= x); assert(x < TLen(n));
  int id = 0;
  vector<int> par(n, -1);
  getParDfs(n, x, -1, id, par);
  return par;
}
vector<int> getPar(const Id &id) {
  return getPar(id.first, id.second);
}
}  // enu_tree

////////////////////////////////////////////////////////////////////////////////


vector<vector<int>> pars;

void exper() {
  using namespace enu_tree;
  build(MAX_N / 2);
  vector<int> dp[MAX_N + 1];
  dp[1] = {1};
  for (int n = 2; n <= MAX_N; ++n) {
    dp[n].assign(TLen(n), 1);
    for (int x = 0; x < TLen(n); ++x) {
      const auto a = T[n][x].first;
      const auto z = T[n][x].second;
      dp[n][x] &= dp[a.first][a.second];
      dp[n][x] &= dp[z.first][z.second];
      if (z.first > 1) {
        const auto b = T[z.first][z.second].first;
        if (a == b) {
          dp[n][x] = 0;
        }
      }
    }
  }
  int sum = 0;
  for (int n = 1; n <= MAX_N; ++n) {
    for (int x = 0; x < TLen(n); ++x) if (n == 1 || T[n][x].first < T[n][x].second) {
      if (dp[n][x]) {
        sum += n;
        // cerr << sum << " " << n << " " << x << " " << getPar(n, x) << endl;
        pars.push_back(getPar(n, x));
        if (sum >= 1'001'001) {
          cerr << n << ": " << sum << " " << pars.size() << endl;
          return;
        }
      }
    }
    cerr << n << ": " << sum << endl;
  }
}


int N;
vector<int> A, B;

void init() {
  A.clear();
  B.clear();
}
void ae(int u, int v) {
  A.push_back(u);
  B.push_back(v);
}

bool solve() {
  init();
  if (N == 1) {
    return true;
  } else if (N <= 5) {
    return false;
  } else if (N == 6) {
    ae(0, 1);
    ae(1, 2);
    ae(2, 0);
    ae(1, 3);
    ae(2, 4);
    ae(4, 5);
    return true;
  }
  int n = 0;
  for (int k = 0; n < N; ++k) {
    if (n + (int)pars[k].size() < N && n + (int)pars[k].size() + (int)pars[k + 1].size() > N) {
      assert(N - n >= 7);
      ae(n + 0, n + 1);
      ae(n + 0, n + 2); ae(n + 2, n + 3);
      int p = n + 0;
      for (int u = n + 4; u < N; ++u) {
        ae(p, u);
        p = u;
      }
      n = N;
      break;
    }
    const int dn = pars[k].size();
    for (int u = 1; u < dn; ++u) {
      ae(n + pars[k][u], n + u);
    }
    n += dn;
  }
  return true;
}

int main() {
  exper();
  
  for (; ~scanf("%d", &N); ) {
    const bool res = solve();
    if (res) {
      const int M = A.size();
      puts("YES");
      printf("%d\n", M);
      for (int i = 0; i < M; ++i) {
        printf("%d %d\n", A[i] + 1, B[i] + 1);
      }
    } else {
      puts("NO");
    }
  }
  return 0;
}