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 math
  import fractions
  
  # import sys
  # input = sys.stdin.readline
  
  
  def make_divisors(n):
      divisors = []
      for i in range(1, int(n**0.5) + 1):
          if n % i == 0:
              divisors.append(i)
              if i != n // i:
                  divisors.append(n // i)
  
      # divisors.sort()
      return divisors
  
  
  def ValueToBits(x, digit):
      res = [0 for i in range(digit)]
      now = x
      for i in range(digit):
          res[i] = now % 2
          now = now >> 1
      return res
  
  
  def BitsToValue(arr):
      n = len(arr)
      ans = 0
      for i in range(n):
          ans += arr[i] * 2**i
      return ans
  
  
  def ZipArray(a):
      aa = [[a[i], i] for i in range(n)]
  
      aa.sort(key=lambda x: x[0])
      for i in range(n):
          aa[i][0] = i + 1
      aa.sort(key=lambda x: x[1])
      b = [aa[i][0] for i in range(len(a))]
      return b
  
  
  def ValueToArray10(x, digit):
      ans = [0 for i in range(digit)]
      now = x
      for i in range(digit):
          ans[digit - i - 1] = now % 10
          now = now // 10
      return ans
  
  
  def Zeros(a, b):
      if b <= -1:
          return [0 for i in range(a)]
      else:
          return [[0 for i in range(b)] for i in range(a)]
  
  
  class Bit:
      def __init__(self, n):
          self.size = n
          self.tree = [0] * (n + 1)
  
      def sum(self, i):
          s = 0
          while i > 0:
              s += self.tree[i]
              i -= i & -i
          return s
  
      def add(self, i, x):
          while i <= self.size:
              self.tree[i] += x
              i += i & -i
  
  
  """
  def cmb(n, r, p):
      if (r < 0) or (n < r):
          return 0
      r = min(r, n - r)
      return fact[n] * factinv[r] * factinv[n-r] % p
  
  p = 2
  N = 10 ** 6 + 2
  fact = [1, 1]  # fact[n] = (n! mod p)
  factinv = [1, 1]  # factinv[n] = ((n!)^(-1) mod p)
  inv = [0, 1]  # factinv 計算用
  
  for i in range(2, N + 1):
      fact.append((fact[-1] * i) % p)
      inv.append((-inv[p % i] * (p // i)) % p)
      factinv.append((factinv[-1] * inv[-1]) % p)
  
  """
  
  # a = list(map(int, input().split()))
  
  #################################################
  #################################################
  #################################################
  #################################################
  
  
  n, x = list(map(int, input().split()))
  
  
  if x == 1 or x == n * 2 - 1:
      print("No")
      exit()
  
  if x == n:
      for i in range(2 * n - 1):
          print(i + 1)
      exit()
  elif x < n:
      nums = [-1 for i in range(2 * n - 1)]
      used = [0 for i in range(2 * n)]
      used[0] = 1
      nums[n - 1] = x
      nums[n] = x - 1
      nums[n - 2] = x + 1
      nums[n - 3] = x + 2
      used[x] = used[x - 1] = used[x + 1] = used[x + 2] = 1
      # print(nums,used)
      now = 0
      pos = 0
      while pos < 2 * n - 1:
          if used[now] == 1:
              now += 1
              continue
          if nums[pos] != -1:
              pos += 1
              continue
          nums[pos] = now
          used[now] = 1
          pos += 1
          now += 1
  
  else:
      nums = [-1 for i in range(2 * n - 1)]
      used = [0 for i in range(2 * n)]
      used[0] = 1
      nums[n - 1] = x
      nums[n] = x + 1
      nums[n - 2] = x - 1
      nums[n - 3] = x - 2
      used[x] = used[x + 1] = used[x - 1] = used[x - 2] = 1
      # print(nums,used)
      now = 0
      pos = 0
      while pos < 2 * n - 1:
          if used[now] == 1:
              now += 1
              continue
          if nums[pos] != -1:
              pos += 1
              continue
          nums[pos] = now
          used[now] = 1
          pos += 1
          now += 1
  
  
  print("Yes")
  for i in nums:
      print(i)
  
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."}]