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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

-- https://github.com/minoki/my-atcoder-solutions
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE BangPatterns #-}
import Control.Monad
import Data.Bits
import Data.Monoid
import qualified Data.ByteString.Builder as BSB
import System.IO

printEdge :: Int -> Int -> IO ()
printEdge !i !j = BSB.hPutBuilder stdout $ BSB.intDec i <> BSB.char7 ' ' <> BSB.intDec j <> BSB.char7 '\n'

main = do
  n :: Int <- readLn
  if n .&. (n-1) == 0 -- n = 2^k for some k
    then putStrLn "No"
    else do putStrLn "Yes"
            let m = bit (floor (logBase 2 (fromIntegral (n+1))))
            forM_ [1..m-2] $ \i -> do
              printEdge i (i+1)
            printEdge (m-1) (n+1)
            forM_ [1..m-2] $ \i -> do
              printEdge (n+i) (n+i+1)
            when (n >= m + 1) $ do
              printEdge 1 m
              printEdge m (m+1)
              printEdge 1 (n+m+1)
              printEdge (n+m+1) (n+m)
              when (n >= m + 2) $ do
                printEdge 2 (m+2)
                printEdge (n+m+1) (n+m+2)
                when (n >= m + 3) $ do
                  printEdge m (m+3)
                  printEdge 2 (n+m+3)
                  when (n >= m + 4) $ do
                    printEdge m (n+m+4)
                    printEdge 4 (m+4)
                    forM_ [m+5..n] $ \i -> do
                      printEdge (i-1) (n+i)
                      printEdge (i-m) i