Problem:
Score : 800 points

Problem Statement

You are given integers N,\ A and B.
Determine if there exists a permutation (P_0,\ P_1,\ ...\ P_{2^N-1}) of (0,\ 1,\ ...\ 2^N-1) that satisfies all of the following conditions, and create one such permutation if it exists.

P_0=A

P_{2^N-1}=B

For all 0 \leq i < 2^N-1, the binary representations of P_i and P_{i+1} differ by exactly one bit.

Constraints

1 \leq N \leq 17

0 \leq A \leq 2^N-1

0 \leq B \leq 2^N-1

A \neq B

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N A B

Output

If there is no permutation that satisfies the conditions, print NO.

If there is such a permutation, print YES in the first line.
Then, print (P_0,\ P_1,\ ...\ P_{2^N-1}) in the second line, with spaces in between.
If there are multiple solutions, any of them is accepted.

Sample Input 1

2 1 3

Sample Output 1

YES
1 0 2 3

The binary representation of P=(1,0,2,3) is (01,00,10,11), where any two adjacent elements differ by exactly one bit.

Sample Input 2

3 2 1

Sample Output 2

NO

Solution in Scala (2.11.7) (judge verdict: Time Limit Exceeded)

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

object Main {

  val amari = 1000000007

  def main(args: Array[String]): Unit = {
    val sc = new java.util.Scanner(System.in)
    val N, A, B = sc.nextInt()
    val xor = A^B
    val xs = Stream.from(0).map(x => Math.pow(2, x).toInt).takeWhile(_ <= Math.max(A, B)).reverse
    val ys = xs.reverse
    val s = xs.map {
      x =>
        (xor / x) % 2
    }.sum
    if ((s % 2) == 1) {
      println("YES")
      val map = new mutable.HashMap[Int, Boolean]
      var cnt = 1
      for {
        i <- 0 until Math.pow(2, N).toInt
      } {
        map(i) = false
      }
      var s = A
      var e = B
      map(s) = true
      map(e) = true
      val arr1 = new ArrayBuffer[Int]()
      val arr2 = new ArrayBuffer[Int]()
      arr1 += s
      arr2 += e
      while (s != 0) {
        cnt = cnt + 1
        s = xs.find(x => s - x >= 0).map(x => s - x).get
        map(s) = true
        arr1 += s
      }
      val max = Math.pow(2, N).toInt - 1
      while (e != max) {
        cnt = cnt + 1
        e = xs.find(x => s + x <= max).map(x => s + x).get
        map(e) = true
        arr2 += e
      }
      map(e) = false
      while (cnt < Math.pow(2, N)) {
        cnt = cnt + 1
        s = ys.find(x => !map(s + x)).map(x => s + x).get
        map(s) = true
        arr1 += s
      }
      println((arr1 ++ arr2.reverse.tail).mkString(" "))
    } else {
      println("NO")
    }
  }
}