output_description: 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.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
attempt: import sys
  
  # sys.stdin=open("data.txt")
  input = sys.stdin.readline
  mii = lambda: map(int, input().split())
  
  # n=4k+3 <=> the line graph works
  # these fail: 1 2 4 8 16 32 ...
  
  # 1 2 3 1 2 3
  # 4 5 1 4 5
  # 6 7 1 6 7
  
  # so n=2k+1 (except n=1) works
  
  
  def get(n):
      e = []
      p = 1
      while p * 2 <= n:
          p *= 2
      if n != p:
          # make line graph
          m = n
          while m % 4 != 3:
              m -= 1
          for i in range(1, m):
              e.append([i, i + 1])
              e.append([n + i, n + i + 1])
          e.append([m, n + 1])
          if n % 4 == 1 or n % 4 == 2:
              m = n
              if n % 4 == 2:
                  m -= 1
              e.append([m - 1, m])
              e.append([m, n + 1])
              e.append([n + 1, n + m - 1])
              e.append([n + m - 1, n + m])
          if n % 4 == 0 or n % 4 == 2:  # not a power of 2
              t = n - 1
              e.append([n, t])
              for i in range(1, n + 1):
                  t ^= i
                  if t == n:
                      e.append([n + i, n + n])
                      break
      return e
  
  
  n = int(input())
  e = get(n)
  for i, j in e:
      print("%d %d" % (i, j))
  
  """
  def dfs(u):
      vis[u]=1
      root[u]^=(u-1)%n+1
      for v in g[u]:
          if vis[v]: continue
          root[v]=root[u]
          dfs(v)
  
  for n in range(1,50):
      g=[[] for _ in range(2*n+1)]
      e=get(n)
      if not e: continue
      assert len(e)==n*2-1
      for i,j in e:
          g[i].append(j)
          g[j].append(i)
      for i in range(1,n+1):
          vis=[0]*(2*n+1)
          root=[0]*(2*n+1)
          dfs(i)
          assert root[n+i]==i
  """
  
problem_description: 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.
samples: [{"input": "3", "output": "Yes\n    1 2\n    2 3\n    3 4\n    4 5\n    5 6\n    \n\n  * The sample output represents the following graph: \n\n![d004b05438497d50637b534e89f7a511.png](https://img.atcoder.jp/agc035/d004b05438497d50637b534e89f7a511.png)\n\n* * *"}, {"input": "1", "output": "No\n    \n\n  * There is no tree satisfying the condition."}]