#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int eval(const vector<int> &ps) {
  const int n = ps.size();
  vector<vector<int>> f(n, vector<int>(n, 0));
  for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) if (ps[i] > ps[j]) ++f[i][j];
  for (int i = n - 1; --i >= 0; ) for (int j = 0; j < n; ++j) f[i][j] += f[i + 1][j];
  for (int i = 0; i < n; ++i) for (int j = 1; j < n; ++j) f[i][j] += f[i][j - 1];
  int k = 0;
  for (int i = 0; i < n; ++i) for (int j = i; j < n; ++j) if (f[i][j] & 1) ++k;
  return k;
}

vector<int> getBest(int n) {
  assert(n >= 4);
  if (n % 2 != 0) {
    auto ps = getBest(n - 1);
    ps.push_back(n - 1);
    return ps;
  } else {
    vector<int> ps(n);
    for (int i = 0; i < n; ++i) ps[i] = (i&1) ? (i - 2) : (i + 2);
    ps[1] = 0;
    ps[n - 2] = n - 1;
    return ps;
  }
}

vector<int> getCest(int n) {
  assert(n >= 6);
  assert(n % 2 == 0);
  vector<int> ps(n);
  for (int i = 0; i < n; ++i) ps[i] = (i&1) ? (i + 2) : (i - 2);
  ps[0] = 0;
  ps[2] = 1;
  ps[n - 3] = n - 2;
  ps[n - 1] = n - 1;
  return ps;
}

vector<int> move(vector<int> ps, int i0, int a0) {
  const int n = ps.size();
  for (int i = 0; i < n; ++i) if (i0 != i && ps[i] > ps[i0]) --ps[i];
  for (int i = 0; i < n; ++i) if (i0 != i && ps[i] >= a0) ++ps[i];
  ps[i0] = a0;
  return ps;
}

int calc(int n) {
  if (n == 1) return 0;
  if (n == 2) return 1;
  if (n == 3) return 3;
  assert(n >= 4);
  return n*(n-1)/2 - (n - 1) / 2;
}

vector<int> solve(int N, int K) {
  if (!(0 <= K && K <= calc(N))) return {};
  
  // zero
  if (K == 0) {
    vector<int> ps(N);
    for (int i = 0; i < N; ++i) ps[i] = i;
    return ps;
  }
  
  // easy
  if (1 <= K && K <= N - 2) {
    vector<int> ps(N);
    for (int i = 0; i < N; ++i) ps[i] = i;
    ps[K - 1] = K + 1;
    ps[K    ] = K - 1;
    ps[K + 1] = K    ;
    return ps;
  }
  
  // inductive
  if (N - 2 >= 1 && (N - 1) <= K && K <= calc(N - 2) + (N - 1)) {
    int n = N, k = K;
    do {
      k -= (n - 1);
      n -= 2;
    } while (n - 2 >= 1 && (n - 1) <= k && k <= calc(n - 2) + (n - 1));
    auto ps = solve(n, k);
    for (; n < N; ) {
      n += 2;
      ps.push_back(n - 1);
      ps.push_back(n - 2);
    }
    return ps;
  }
  
  if (N >= 4) {
    const int d = calc(N) - K;
    const auto best = getBest(N);
    // best
    if (d == 0) return best;
    // cest or move
    if (d == 1) {
      if (N >= 6 && N % 2 == 0) return getCest(N);
      if (N >= 7 && N % 2 != 0) return move(best, N - 1, N - 5);
    }
    // move
    if (d == 2) return move(best, 0, 0);
    int now = 2, a = 4;
    for (; ; ) {
      ++now;
// cerr<<"N = "<<N<<", now = "<<now<<", a = "<<a<<endl;
      if (d == now) return move(best, 0, a);
      a = (a % 2 != 0) ? (a - 2) : (a == N - 3) ? (a - 1) : (a == N - 4) ? (a + 1) : (a + 2);
    }
  }
  
  // special
  if (N == 2 && K == 1) return {1, 0};
  if (N == 3 && K == 3) return {2, 1, 0};
  
cerr<<"HELP "<<N<<" "<<K<<endl;
  assert(false);
}

void expr() {
  constexpr int LIM_N = 11;
  vector<vector<vector<vector<int>>>> brt(LIM_N + 1);
  for (int n = 1; n <= LIM_N; ++n) {
    string status(n*(n-1)/2 + 1, 'x');
    brt[n].assign(n*(n-1)/2 + 1, {});
    {
      vector<int> ps(n);
      for (int i = 0; i < n; ++i) ps[i] = i;
      do {
        const int k = eval(ps);
        status[k] = 'o';
        brt[n][k].push_back(ps);
      } while (next_permutation(ps.begin(), ps.end()));
    }
    for (int k = 0; k <= n*(n-1)/2; ++k) if (brt[n][k].size()) {
      cout << n << " " << k << endl;
      cout << brt[n][k][0] << endl;
      cout << brt[n][k].back() << endl;
      cout << endl;
    }
    
    // zero
    status[0] = '0';
    
    // easy
    for (int i0 = 0; i0 + 3 <= n; ++i0) {
      vector<int> ps(n);
      for (int i = 0; i < n; ++i) ps[i] = i;
      ps[i0 + 0] = i0 + 2;
      ps[i0 + 1] = i0 + 0;
      ps[i0 + 2] = i0 + 1;
      const int k = eval(ps);
// cerr<<n<<" "<<i0<<" "<<ps<<" "<<k<<endl;
      if (status[k] == 'o') status[k] = 'E';
    }
    
    // inductive
    if (n - 2 >= 1) {
      for (int k2 = 0; k2 <= (n-2)*(n-3)/2; ++k2) if (brt[n - 2][k2].size()) {
        auto ps = brt[n - 2][k2][0];
        ps.push_back(n - 1);
        ps.push_back(n - 2);
        const int k = eval(ps);
        assert(k2 + (n - 1) == k);
        if (status[k] == 'o') status[k] = 'I';
      }
    }
    
    // best
    if (n >= 4) {
      const auto ps = getBest(n);
      const int k = eval(ps);
      assert(k == calc(n));
cerr<<"best "<<n<<" "<<ps<<" "<<k<<endl;
      if (status[k] == 'o') status[k] = 'B';
    }
    
    // cest
    if (n >= 6 && n % 2 == 0) {
      const auto ps = getCest(n);
      const int k = eval(ps);
// cerr<<"cest "<<n<<" "<<ps<<" "<<k<<endl;
      if (status[k] == 'o') status[k] = 'C';
    }
    
    // move
    if (n >= 4) {
      const auto best = getBest(n);
      for (const int i0 : {0, n - 1}) for (int a0 = 0; a0 < n; ++a0) {
        const auto ps = move(best, i0, a0);
        const int k = eval(ps);
cerr<<"move "<<n<<" "<<i0<<" "<<a0<<" "<<ps<<" "<<k<<endl;
        if (status[k] == 'o') status[k] = 'M';
      }
    }
    
    cerr << (n/10) << (n%10) << ": " << status;
    if (n - 2 >= 1) cerr << " " << calc(n) << " " << (calc(n - 2) + (n - 1));
    cerr << endl;
    
    for (int k = 0; k <= n*(n-1)/2; ++k) if (status[k] == 'o') {
      cerr << "special " << n << " " << k << endl;
      for (const auto &ps : brt[n][k]) {
        cerr << ps << endl;
      }
    }
    
    for (int k = 0; k <= n*(n-1)/2; ++k) {
      const auto slv = solve(n, k);
      if (brt[n][k].size()) {
        assert(slv.size());
        auto it = lower_bound(brt[n][k].begin(), brt[n][k].end(), slv);
        if (it != brt[n][k].end() && *it == slv) {
          //
        } else {
          cerr << "FAIL " << n << " " << k << ": " << slv << endl;
          assert(false);
        }
      } else {
        assert(!slv.size());
      }
    }
    cerr << "PASSED n = " << n << endl;
  }
  
  for (int n = LIM_N + 1; n <= 20; ++n) {
    for (int k = 0; k <= n*(n-1)/2; ++k) {
      const auto slv = solve(n, k);
      if (k <= calc(n)) {
        assert(slv.size());
        assert(k == eval(slv));
      } else {
        assert(!slv.size());
      }
    }
    cerr << "PASSED n = " << n << endl;
  }
}

int main() {
  // expr();
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    int N, K;
    scanf("%d%d", &N, &K);
    
    const auto ans = solve(N, K);
    if (ans.size()) {
      puts("YES");
      for (int i = 0; i < N; ++i) {
        if (i) printf(" ");
        printf("%d", ans[i] + 1);
      }
      puts("");
    } else {
      puts("NO");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}