output_description: If no permutation of (1, 2, ..., 2N-1) could have been written into the blocks
  of step N, print `No`.
  
  Otherwise, print `Yes` in the first line, then print 2N-1 lines in addition.
  
  The i-th of these 2N-1 lines should contain the i-th element of a possible
  permutation.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N x
attempt: # 愚直解
  #  from itertools import permutations
  
  # # n = int(input())
  # # kumiawase = list(permutations(range(1, 2 * n), 2 * n - 1))
  # ans_set = set()
  # kumiawase = [(3, 4, 5, 6, 1, 2, 7, 8, 9, 10, 11)]
  # for kumi in kumiawase:
  #     kouho = kumi
  #     while kouho:
  #         nex = []
  #         for i in range(len(kouho) - 2):
  #             temp = [kouho[i], kouho[i + 1], kouho[i + 2]]
  #             temp.sort()
  #             nex.append(temp[1])
  #         if len(nex) == 1:
  #             break
  #         kouho = nex[::]
  #         print(kouho)
  #     ans_set.add(nex[0])
  #     if nex[0] == 2:
  #         print(kumi)
  #         exit()
  
  # print(ans_set)
  
  n, x = map(int, input().split())
  
  if x <= 1 or x >= 2 * n - 1:
      print("No")
      exit()
  if n == 2:
      print("Yes")
      for i in range(3):
          print(i + 1)
      exit()
  
  ans = [0] * (2 * n - 1)
  used = [False] * (2 * n)
  
  if x <= n:
      ans[n - 1] = x
      ans[n - 2] = x - 1
      ans[n] = x + 1
      ans[n - 3] = x + 2
      used[x] = True
      used[x - 1] = True
      used[x + 1] = True
      used[x + 2] = True
      num = 1
      for i in range(2 * n - 1):
          if ans[i] == 0:
              while used[num]:
                  num += 1
              ans[i] = num
              num += 1
      print("Yes")
      print(*ans, sep="\n")
  else:
      ans[n - 1] = x
      ans[n - 2] = x + 1
      ans[n] = x - 1
      ans[n - 3] = x - 2
      used[x] = True
      used[x + 1] = True
      used[x - 1] = True
      used[x - 2] = True
      num = 1
      for i in range(2 * n - 1):
          if ans[i] == 0:
              while used[num]:
                  num += 1
              ans[i] = num
              num += 1
      print("Yes")
      print(*ans, sep="\n")
  
problem_description: Statement
  
  We have a pyramid with N steps, built with blocks. The steps are numbered 1
  through N from top to bottom. For each 1≤i≤N, step i consists of 2i-1 blocks
  aligned horizontally. The pyramid is built so that the blocks at the centers
  of the steps are aligned vertically.
  
  ![](https://atcoder.jp/img/agc006/a2bde72df5ad036d1699f4a74d74a370.png)
  
  A pyramid with N=4 steps
  
  Snuke wrote a permutation of (1, 2, ..., 2N-1) into the blocks of step N.
  Then, he wrote integers into all remaining blocks, under the following rule:
  
    * The integer written into a block b must be equal to the median of the three integers written into the three blocks directly under b, or to the lower left or lower right of b.
  
  ![](https://atcoder.jp/img/agc006/a940f1d8303f255e1f91d17a5696633f.png)
  
  Writing integers into the blocks
  
  Afterwards, he erased all integers written into the blocks. Now, he only
  remembers that the integer written into the block of step 1 was x.
  
  Construct a permutation of (1, 2, ..., 2N-1) that could have been written into
  the blocks of step N, or declare that Snuke's memory is incorrect and such a
  permutation does not exist.
samples: [{"input": "4 4", "output": "Yes\n    1\n    6\n    3\n    7\n    4\n    5\n    2\n    \n\nThis case corresponds to the figure in the problem statement.\n\n* * *"}, {"input": "2 1", "output": "No\n    \n\nNo matter what permutation was written into the blocks of step N, the integer\nwritten into the block of step 1 would be 2."}]