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: #!/usr/bin/env python3
  # -*- coding: utf-8 -*-
  
  from itertools import *
  
  
  def bf(n):
      variations = set()
      for comb in permutations(list(range(1, n + 1))):
          top = sim(comb)
          if top not in variations:
              print(top, comb)
              variations.add(top)
          # if top != comb[ len(comb) // 2 ]:
          #     print("exception!")
          #     print("comb, result = ", comb, top)
      print(variations)
  
  
  def sim(comb):
      comb = list(comb)
      while len(comb) != 1:
          n_comb = []
          for i in range(len(comb) - 2):
              arr = comb[i : i + 3]
              arr.sort()
              n_comb.append(arr[1])
          comb = n_comb
          # print(comb[0])
      return comb[0]
  
  
  # bf(3)
  # bf(5)
  # bf(7)
  # bf(9)
  # bf(11)
  
  
  def main():
      N, x = map(int, input().split())
      if N == 1:
          if x == 1:
              print("Yes")
              print(1)
          else:
              print("No")
      else:
          length = N * 2 - 1
          if 2 <= x <= length - 1:
              print("Yes")
              mid = (length + 1) // 2
              if x > mid:
                  flip = True
                  x = length + 1 - x
              else:
                  flip = False
  
              ans = (
                  list(range(1, x - 1))
                  + list(range(x + 1, mid + 1))
                  + list(range(x - 1, x + 1))
                  + list(range(mid + 1, length + 1))
              )
  
              if flip:
                  ans2 = [length + 1 - x for x in ans]
                  ans = ans2
              for e in ans:
                  print(e)
          else:
              print("No")
  
  
  main()
  
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."}]