#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ui unsigned long long
#define fast() ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ld long double
#define pb push_back
#define SZ(a) (ll)(a.size())
#define FOR(i,a,n) for(ll i=a;i<=n;i++)
#define FORr(i,a,n) for(ll i=n;i>=a;i--)
#define trav(m,a) for(auto m:a){cout<<m<<" ";}cout<<"\n";
#define travP(m,a) for(auto m:a){cout<<m.first<<" "<<m.second<<"\n";}cout<<"\n";
#define read(a,n) FOR(i,1,n){ll q;cin>>q;a.pb(q);}
#define vi vector<int>
#define vll vector<ll>
#define F first
#define S second
#define pie 3.141592654
#define MAX 9000000000000000000
#define MIN -9000000000000000000
#define print(a) cout<<a<<"\n"
template<class T>using oset=tree<T,null_type,less_equal<T>,rb_tree_tag,tree_order_statistics_node_update>;//multiset-less_equal
bool cmp(const pair<ll,ll>&a,const pair<ll,ll>&b){
    if(a.S==b.S){return a.F<b.F;}
    return a.S<b.S;
}
const int N = 2e5 + 5;
const int LOG = 20;
ll st[N][LOG];
ll L[N];
int lg[N];
void build_log(int n) {
    lg[1] = 0;
    for (int i = 2; i <= n; i++) {
        lg[i] = lg[i / 2] + 1;
    }
}
void build_sparse(int n) {
    for (int i = 1; i <= n; i++) {
        st[i][0] = L[i];
    }
    for (int j = 1; j < LOG; j++) {
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
            st[i][j] = min(st[i][j-1], st[i + (1 << (j-1))][j-1]);
        }
    }
}
ll query(int L, int R) {
    int j = lg[R - L + 1];
    return min(st[L][j], st[R - (1 << j) + 1][j]);
}
ll st1[N][LOG];
ll R[N];
void build_sparse1(int n) {
    for (int i = 1; i <= n; i++) {
        st1[i][0] = R[i];
    }
    for (int j = 1; j < LOG; j++) {
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
            st1[i][j] = max(st1[i][j-1], st1[i + (1 << (j-1))][j-1]);
        }
    }
}
ll query1(int L, int R) {
    int j = lg[R - L + 1];
    return max(st1[L][j], st1[R - (1 << j) + 1][j]);
}
//Lazy segment tree for assignment and sum
class SegmentTree{
private:
    vector<ll>tr,lazy,marked;
    ll n;
 
    void build(vector<ll> &arr, int node, int b, int e){
        if(b == e){
            tr[node] = arr[b];
        }
        else{
            int mid = (b + e) / 2;
            build(arr, 2*node, b, mid);
            build(arr, (2*node)+1, mid+1, e);
            tr[node] =  tr[2*node] + tr[(2*node)+1];
        }
    }
    void push(int node,int b,int e){
        if(marked[node] && b!=e){
            int Left = node * 2;
            int Right = (node * 2) + 1;
            int mid = (b + e) / 2;
            lazy[Left] = lazy[Right] = lazy[node];
            tr[Left] = (mid-b+1) * lazy[Left];
            tr[Right] = (e-(mid+1)+1) * lazy[Right];
            marked[Left] = marked[Right] = true;
            marked[node] = false;
        }
    }
    void update(int node, int b, int e, int l, int r, ll x){
        if(l > e || r < b){
            return;
        }
        if(l <= b && e <= r){
            tr[node] = (e-b+1) * x;
            lazy[node] = x;
            marked[node] = true;
            return;
        }
        push(node, b, e);
        int Left = node * 2;
        int Right = (node * 2) + 1;
        int mid = (b + e) / 2;
        update(Left, b, mid, l, r, x);
        update(Right, mid + 1, e, l, r, x);
        tr[node] = tr[Left] + tr[Right];
    }
    ll query(int node, int b, int e, int l, int r){
        if (l > e || r < b){
            return 0ll;
        }
        if (b >= l and e <= r){
            return tr[node];
        }
        push(node, b, e);
        int Left = node << 1;
        int Right = (node << 1) + 1;
        int mid = (b + e) >> 1;
 
        ll p1 = query(Left, b, mid, l, r);
        ll p2 = query(Right, mid + 1, e, l, r);
 
        return (ll)(p1 + p2);
    }
public:
    SegmentTree(vector<ll> &arr){
        n = (int)arr.size() - 1;
        tr.resize(4 * n, 0ll);
        lazy.resize(4 * n, 0ll);
        marked.resize(4 * n, 0ll);
        build(arr, 1, 1, n);
    }
    void upd(int l,int r,ll val){
        update(1, 1, n, l, r, val);
    }
    ll qr(int l,int r){
        return query(1, 1, n, l, r);
    }
};
int main(){
    fast();
    int T;cin>>T;
    while(T--){
        int n,x;cin>>n>>x;vector<ll>a(n+1),pref(n+1);
        vector<vector<int>>store(n+2);
        FOR(i,1,n){
            cin>>a[i];pref[i]=a[i]+pref[i-1];
        }
        for(int i=1;i<=n;i++){
            int l=i+1,r=n,res=n+1;
            while(l<=r){
                int mid=(l+r)/2;
                if(pref[mid]-pref[i]>=a[i]){
                    res=mid;r=mid-1;
                }
                else{l=mid+1;}
            }
            R[i]=res;store[res].pb(i);
            l=1;r=i-1;res=0;
            while(l<=r){
                int mid=(l+r)/2;
                if(pref[i-1]-pref[mid-1]>=a[i]){
                    res=mid;l=mid+1;
                }
                else{r=mid-1;}
            }
            L[i]=res;
        }
        build_log(n);
        build_sparse(n);
        build_sparse1(n);
        vector<ll>cnt(n+1);
        SegmentTree seg(cnt);
        vector<int>ans(n+1);
        for(int i=1;i<=n;i++){
            for(auto M:store[i]){
                int l=M+1,r=i,res=-1;
                while(l<=r){
                    int mid=(l+r)/2;
                    int mn=query(mid, i);
                    if(mn<=M){
                        res=mid;l=mid+1;
                    }
                    else{r=mid-1;}
                }
                if(res!=-1 && M+1<=res-1){
                    seg.upd(M+1, res-1, 1);
                }
            }
            if(i>1 && !L[i]){
                seg.upd(1, i-1, 1);
            }
            ll l=1,r=i-1,res=-1;
            while(l<=r){
                int mid=(l+r)/2;
                int mx=query1(1, mid);
                if(mx>i){res=mid;r=mid-1;}
                else{l=mid+1;}
            }
            if(res==-1){res=i;}
            ans[i]=res-seg.qr(1, res);
        }
        for(int i=1;i<=n;i++){
            cout<<ans[i]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}