Problem:
Score : 400 points

Problem 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.

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.

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.

Constraints

2≤N≤10^5

1≤x≤2N-1

Input

The input is given from Standard Input in the following format:

N x

Output

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.

Sample Input 1

4 4

Sample Output 1

Yes
1
6
3
7
4
5
2

This case corresponds to the figure in the problem statement.

Sample Input 2

2 1

Sample Output 2

No

No matter what permutation was written into the blocks of step N, the integer written into the block of step 1 would be 2.

Solution in C++14 (GCC 5.4.1) (judge verdict: Runtime Error)

#include <bits/stdc++.h>

// statics
using namespace std;
using int64 = int_fast64_t;
using PAIR = pair<int64, int64>;
constexpr int INF = 1 << 30;
constexpr int64 LINF = 1LL << 60;
constexpr int MOD = 1e9 + 7;
constexpr int MAX_N = 3e5 + 1;

// init/input
#define int int64
#define INIT ios::sync_with_stdio(false);cin.tie(0);
#define VAR(type, ...) type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T &t) {cin>>t;}
template<typename First, typename...Rest> void MACRO_VAR_Scan(First &first, Rest&...rest) {cin>>first;MACRO_VAR_Scan(rest...);}
#define VEC(type, c, n) vector<type> c(n);for(auto &&i:c)cin>>i;

// out
#define OUT(dist) cout<<(dist);
#define FOUT(n, dist) cout<<fixed<<setprecision(n)<<(dist);
#define SP cout<<" ";
#define BR cout<<endl;
#define zero(n) cout<<setfill('0')<<right<<setw(n)
#define debug(x) cerr<<#x<<":"<< (x);BR;

// utility
#define ALL(a) (a).begin(), (a).end()
#define EACH(i, a) for(auto &&i:(a))
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=0;--i)
#define REP(i, n) for(int i=0;i<(n);++i)
#define RREP(i, n) for(int i=(n)-1;i>=0;--i)

// あるブロックに書き込まれる整数は, そのブロックの左下, 真下, 右下のブロックの中央値である
// 一番上のブロックがxの時, 存在するN段目の並びを求めよ(1, ..., 2N-1とする)
//   x
// i x j (i<=x, x<=j)
// xが(1)or(2N-1)の時は無理
// 2の時は?
//     2
//   2 2 4
// 1 3 2 4 5

// 4, 4
//       4
//     3 4 5
//   2 3 4 5 6
// 1 2 3 4 5 6 7

// 一般化すると,
// 同じ数字が2個並べば良い
// x-1, x, x+1, x-2とすれば良いらしい
// ただし, x=2の時は+-を逆にすれば良い
// x+1, x, x-1, x+2

signed main() {
  INIT;
	VAR(int, n, x);

	if (x==1 || x==2*n-1){
	  OUT("No")BR;
		return 0;
	}
	OUT("Yes")BR;
	vector<int> ans(2*n-1);
	int cnt = 1;
  if (x==2){
		ans[n-2] = x+1;
		ans[n-1] = x;
		ans[n] = x-1;
		ans[n+1] = x+2;
		REP(i,2*n-1){
			if (n-2 <= i && i<= n+1) continue;
			while (x-1 <= cnt && cnt <= x+2) ++cnt;
			ans[i] = cnt++;
		}
		EACH(ai,ans) {
			OUT(ai)BR;
		}
		return 0;
	}
	ans[n-2] = x-1;
	ans[n-1] = x;
	ans[n] = x+1;
	ans[n+1] = x-2;
	REP(i,2*n-1){
		if (n-2 <= i && i<= n+1) continue;
		while (x-2 <= cnt && cnt <= x+1) ++cnt;
		ans[i] = cnt++;
	}
	EACH(ai,ans) {
		OUT(ai)BR;
	}
	
  
  return 0;
}