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

#define int long long

namespace min_cost_max_flow{
	const int MAXN=6411,MAXM=50333;
	struct edge{
		int v,f,w;
		edge *next,*rev;
	}*h[MAXN],pool[MAXM*2];
	int top;
	inline void addedge(int u,int v,int c,int w){
	//	cerr << "add : " << u << " " << v << " " << c << " " << w << endl;
		edge *tmp=&pool[top++];tmp->v=v;tmp->f=c;tmp->w=w;tmp->next=h[u];h[u]=tmp;
		edge *pmt=&pool[top++];pmt->v=u;pmt->f=0;pmt->w=-w;pmt->next=h[v];h[v]=pmt;
		tmp->rev=pmt;pmt->rev=tmp;
	}
	deque<int> q;
	int S,T;
	int last[MAXN],inq[MAXN];
	long long dis[MAXN],maxf[MAXN];
	edge *laste[MAXN];
	int totcost,totflow;
	bool SPFA(){
		memset(dis,0x3f,sizeof(dis));
		memset(last,0,sizeof(last));
		memset(maxf,0,sizeof(maxf));
		memset(inq,0,sizeof(inq));
		while(!q.empty())q.pop_front();
		q.push_front(S);
		maxf[S]=0x3f3f3f3f3f3f3f3fll;
		inq[S]=1;
		dis[S]=0;
		while (!q.empty()){
			int u=q.front();q.pop_front();
			inq[u]=0;
			for (edge *tmp=h[u];tmp;tmp=tmp->next){
				if (tmp->f && dis[tmp->v]>dis[u]+tmp->w){
					dis[tmp->v]=dis[u]+tmp->w;
					last[tmp->v]=u;
					maxf[tmp->v]=max(maxf[tmp->v],min(maxf[u],(long long)tmp->f));
					laste[tmp->v]=tmp;
					if (!inq[tmp->v]){
						if (q.empty() || dis[q.front()]>tmp->v) q.push_front(tmp->v);
						else q.push_back(tmp->v);
						inq[tmp->v]=1;	
					}
				}
			}
		}
		if (dis[T]>=0x3f3f3f3f3f3f3f3fll) return false;
		int u=T;
		while (last[u]){
			laste[u]->f-=maxf[T];
			laste[u]->rev->f+=maxf[T];
			u=last[u];
		}
		totcost+=dis[T]*maxf[T];
		totflow+=maxf[T];
		return true;
	}
	void init(int _S,int _T){
		S=_S;
		T=_T;
		top=0;
		memset(h,0,sizeof(h));
		totcost=0;
		totflow=0;
	}
}

typedef long long ll;
const ll lim=51;

ll n,m;
ll a[55],b[55],c[55];

signed main(){
	ios_base::sync_with_stdio(false);
	int Tcase=1;
	cin >> Tcase;
	for (;Tcase--;){
		cin >> n >> m;
		for (int i=1;i<=n;i++) cin >> a[i] >> b[i] >> c[i];
		map<ll,ll> dict;
		for (int i=1;i<=n;i++){
			ll l=1,r=m;
			ll pos=-b[i]/(2*a[i]);
			pos=max(pos,l);
			pos=min(pos,r);
			l=max(l,pos-lim);
			r=min(r,pos+lim);
			for (ll j=l;j<=r;j++) dict[j]=0;
		}
		ll id=0;
		for (auto &[x,y]:dict) y=++id;	
		
		int _S=n+id+1;
		int _T=n+id+2;
		min_cost_max_flow::init(_S,_T);
		
		for (int i=1;i<=n;i++) min_cost_max_flow::addedge(_S,i,1,0);
		for (int j=1;j<=id;j++) min_cost_max_flow::addedge(j+n,_T,1,0);
		for (int i=1;i<=n;i++){
			
			ll l=1,r=m;
			ll pos=-b[i]/(2*a[i]);
			pos=max(pos,l);
			pos=min(pos,r);
			l=max(l,pos-lim);
			r=min(r,pos+lim);
			
			for (int j=l;j<=r;j++){
				ll numj=dict[j];
				min_cost_max_flow::addedge(i,numj+n,1,a[i]*j*j+b[i]*j+c[i]);
			}
		}
		
		vector<long long> ans;
		ans.push_back(0LL);
		for (int i=1;i<=n;i++){
			min_cost_max_flow::SPFA();
		//	cerr << min_cost_max_flow::totflow << " " << min_cost_max_flow::totcost << endl; 
			ans.push_back(min_cost_max_flow::totcost);
		}
		for (int i=1;i<=n;i++) cout << ans[i] << " \n"[i==n];
	}
	return 0;	
}