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: import sys,bisect as bs,collections as cl,heapq as hq
  sys.setrecursionlimit(100000)
  mod = 10**9+7
  Max = sys.maxsize
  def l(): #intのlist
      return list(map(int,input().split()))
  def m(): #複数文字
      return map(int,input().split())
  def onem(): #Nとかの取得
      return int(input())
  def s(x): #圧縮
      a = []
      aa = x[0]
      su = 1
      for i in range(len(x)-1):
          if aa != x[i+1]:
              a.append([aa,su])
              aa = x[i+1]
              su = 1
          else:
              su += 1
      a.append([aa,su])
      return a
  def jo(x): #listをスペースごとに分ける
      return " ".join(map(str,x))
  def max2(x): #他のときもどうように作成可能
      return max(map(max,x))
  def In(x,a): #aがリスト(sorted)
      k = bs.bisect_left(a,x)
      if k != len(a) and a[k] ==  x:
          return True
      else:
          return False
  
  n,m = m()
  
  if m == 1 or 2*n-1 == m:
      print("No")
  else:
      print("Yes")
      if n == 2:
          ans = [1,2,3]
          print(jo(ans))
      else:
          if m == 2:
              a = [3,2,1,4]
              ans = [i + 5 for i in range(n-2)] + a + [i + n+3 for i in range(n-3)]
          else:
              a = [m-1,m,m+1,m-2]
              i = 0
              ans = []
              for j in range(2*n-4):
                  i += 1
                  if j == n-1:
                      ans += a
                      i -= 1
                   else:
                      if i == m-2:
                          i += 4
                      ans.append(i)
          print(jo(ans))
  
  
  
  
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."}]