output_description: 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.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N A B
attempt: #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  
  
  def trace(bits, idx, history):
      if idx == len(bits):
          history.append(bits[:])
      elif idx == len(bits) - 1:
          history.append(bits[:])
          bits[idx] = 1 - bits[idx]
          history.append(bits[:])
      else:
          trace(bits, idx + 1, history)
          bits[idx] = 1 - bits[idx]
          trace(bits, idx + 1, history)
  
  
  def down(bits, idx, count, history):
      if idx == len(bits):
          history.append(bits[:])
      elif idx == len(bits) - 1:
          history.append(bits[:])
          bits[idx] = 1 - bits[idx]
          history.append(bits[:])
      elif count > 0:
          trace(bits, idx + 2, history)
          bits[idx] = 1 - bits[idx]
          trace(bits, idx + 2, history)
          bits[idx + 1] = 1 - bits[idx + 1]
          trace(bits, idx + 2, history)
          bits[idx] = 1 - bits[idx]
          down(bits, idx + 2, count - 2, history)
      else:
          trace(bits, idx + 2, history)
          bits[idx + 1] = 1 - bits[idx + 1]
          trace(bits, idx + 2, history)
          bits[idx] = 1 - bits[idx]
          trace(bits, idx + 2, history)
          bits[idx + 1] = 1 - bits[idx + 1]
          down(bits, idx + 2, count - 2, history)
  
  
  def main():
      n, a, b = map(int, input().split())
      x = a ^ b
      count = 0
      remain = 0
      mapper = [-1] * n
  
      for i in range(n):
          if (x >> i) & 0x1 != 0:
              mapper[count] = i
              count += 1
          else:
              remain += 1
              mapper[-remain] = i
  
      if count % 2 == 0:
          print("NO", flush=True)
          return
  
      bits = [0] * n
      history = []
      trace(bits, 1, history)
      bits[0] = 1
      down(bits, 1, count - 1, history)
  
      for i in range(len(history)):
          v = history[i][:]
  
          for j, m in enumerate(mapper):
              history[i][n - m - 1] = v[j]
  
      history = [str(a ^ int("".join(str(v) for v in h), 2)) for h in history]
  
      print("YES", flush=True)
      print(" ".join(history), flush=True)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: 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.
samples: [{"input": "2 1 3", "output": "YES\n    1 0 2 3\n    \n\nThe binary representation of P=(1,0,2,3) is (01,00,10,11), where any two\nadjacent elements differ by exactly one bit.\n\n* * *"}, {"input": "3 2 1", "output": "NO"}]