#include <bits/extc++.h>
#include <bits/stdc++.h>
using namespace std;

template <typename T>
using ordered_set =
    __gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag,
                     __gnu_pbds::tree_order_statistics_node_update>;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto... a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe

#define orange(...) safe
#endif

constexpr int N = 250'000 + 1;
constexpr int L = 40;

constexpr int64_t INF = 1LL << 60;

int64_t dp1[L][L * (L - 1) / 2];
int64_t dp2[N][L];

int64_t add(int64_t a, int64_t b) { return min(a + b, INF); }

int64_t sub(int64_t a, int64_t b) {
  if (a == INF)
    return INF;
  return a - b;
}

int ans[N];

__int128 dp1s[L][L * (L - 1) / 2];
__int128 dp2s[N][L];

int64_t calc(int len, int64_t inv) {
  const int64_t max_inv = int64_t(len) * (len - 1) / 2;
  if (0 > inv or inv > max_inv)
    return 0;
  if (len < L) {
    return dp1[len][inv];
  }
  if (max_inv - L >= inv and inv >= L)
    return INF;
  if (inv >= L)
    return dp2[len][max_inv - inv];
  return dp2[len][inv];
}

__int128 MyGo(int len, int64_t inv, int l) {
  const int64_t max_inv = int64_t(len) * (len - 1) / 2;
  // calc(len, inv - l) + ... + calc(len, inv)
  const int64_t lb = max<int64_t>(inv - l + 1, 0);
  const int64_t rb = min<int64_t>(inv, max_inv);
  if (lb > rb)
    return 0;
  if (len < L) {
    if (lb)
      return dp1s[len][rb] - dp1s[len][lb - 1];
    return dp1s[len][rb];
  } else {
    if (lb >= max_inv - L) {
      return MyGo(len, max_inv - inv + l - 1, l);
    } else if (rb <= L) {
      if (lb)
        return dp2s[len][rb] - dp2s[len][lb - 1];
      return dp2s[len][rb];
    } else {
      return INF;
    }
  }
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);

  dp1[0][0] = 1;
  for (int i = 1; i < L; ++i) {
    const int inv = (i - 2) * (i - 1) / 2;
    for (int j = 0; j <= inv; ++j) {
      for (int k = 0; k <= i - 1; ++k) {
        dp1[i][j + k] = add(dp1[i][j + k], dp1[i - 1][j]);
      }
    }
  }
  dp2[0][0] = 1;
  for (int i = 1; i < N; ++i) {
    const int64_t inv = min<int64_t>(L - 1, int64_t(i - 1) * i / 2);
    int64_t sm = 0;
    for (int j = 0; j <= inv; ++j) {
      if ((j - (i - 1) - 1) >= 0)
        sm = sub(sm, dp2[i - 1][j - (i - 1) - 1]);
      sm = add(sm, dp2[i - 1][j]);
      dp2[i][j] = sm;
      // dp2[i][j] = dp2[i - 1][j - (i - 1)] + ... + dp2[i - 1][j]
    }
  }

  for (int i = 0; i < L; ++i) {
    const int inv = (i - 1) * i / 2;
    for (int j = 0; j <= inv; ++j) {
      dp1s[i][j] = dp1[i][j];
      if (j)
        dp1s[i][j] += dp1s[i][j - 1];
    }
  }
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < L; ++j) {
      dp2s[i][j] = dp2[i][j];
      if (j)
        dp2s[i][j] += dp2s[i][j - 1];
    }
  }

  int n;
  int64_t k;
  cin >> n >> k;

  if (n % 4 == 3 or n % 4 == 2) {
    cout << "NO\n";
    return 0;
  }

  int64_t inv = int64_t(n) * (n - 1) / 4;

  ordered_set<int> exists;
  for (int i = 1; i <= n; ++i)
    exists.insert(i);

  for (int i = 0; i < n; ++i) {
    int l = 0, r = int(exists.size()) + 1;
    while (r - l > 1) {
      int m = (l + r) >> 1;
      if (MyGo(n - i - 1, inv, m) < k)
        l = m;
      else
        r = m;
    }
    if (l == int(exists.size())) {
      cout << "NO\n";
      return 0;
    }
    k -= MyGo(n - i - 1, inv, l);
    inv -= l;
    ans[i] = *exists.find_by_order(l);
    exists.erase(exists.find_by_order(l));
  }
  assert(k == 1);
  assert(inv == 0);
  cout << "YES\n";
  for (int i = 0; i < n; ++i)
    cout << ans[i] << " \n"[i + 1 == n];
  return 0;
}