#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#define int long long

#define db frac

const int maxn=5e5+5;
struct frac{
	int x,y;
	frac(int a=0,int b=1){
		x=a,y=b;
		if(b<0)x=-x,y=-y;
	}
};
inline frac operator +(frac A,frac B){return frac(A.x*B.y+A.y*B.x,A.y*B.y);}
inline frac operator -(frac A,frac B){return frac(A.x*B.y-A.y*B.x,A.y*B.y);}
inline frac operator *(frac A,frac B){return frac(A.x*B.x,A.y*B.y);}
inline frac operator *(frac A,int B){return frac(A.x*B,A.y);}
inline frac operator +(frac A,int B){return frac(A.x+A.y*B,A.y);}
inline bool operator <(frac A,frac B){return A.x*B.y<A.y*B.x;}
inline bool operator >(frac A,frac B){return A.x*B.y>A.y*B.x;}
inline frac operator *=(frac &A,int B){return A=A*B;}
struct line{
	db a,b,c;
	inline db operator ()(db x,db y){return a*x+b*y+c;}
};
namespace Fastio {
    #define USE_FASTIO 1

    #define IN_LEN 450000

    #define OUT_LEN 450000

    char ch, c; int len;
    short f, top, s;
    inline char Getchar() {
        static char buf[IN_LEN], *l = buf, *r = buf;
        if (l == r) r = (l = buf) + fread(buf, 1, IN_LEN, stdin);
        return (l == r) ? EOF : *l++;
    }
    char obuf[OUT_LEN], *ooh = obuf;
    inline void Putchar(char c) {
        if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
        *ooh++ = c;
    }
    inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
    #undef IN_LEN
    #undef OUT_LEN
    struct Reader {
        template <typename T> Reader& operator >> (T &x) {
            x = 0, f = 1, c = Getchar();
            while (!isdigit(c)) { if (c == '-') f *= -1; c = Getchar(); }
            while ( isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = Getchar();
            x *= f;
            return *this;
        }
        
        Reader() {}
    } cin;
    const char endl = '\n';
    struct Writer {
        typedef long long mxdouble;
        template <typename T> Writer& operator << (T x) {
            if (x == 0) { Putchar('0'); return *this; }
            if (x < 0) Putchar('-'), x = -x;
            static short sta[40];
            top = 0;
            while (x > 0) sta[++top] = x % 10, x /= 10;
            while (top > 0) Putchar(sta[top] + '0'), top--;
            return *this;
        }
        Writer& operator << (const char *str) {
            int cur = 0;
            while (str[cur]) Putchar(str[cur++]);
            return *this;
        }
        inline Writer& operator << (char c) {Putchar(c); return *this;}
        Writer() {}
        ~ Writer () {flush();}
    } cout;
    #define cin Fastio::cin

    #define cout Fastio::cout

    #define endl Fastio::endl

}
struct node{
	db mn[2],mx[2];
	int ls,rs,tag,ans,id;
}xds[maxn<<2];
int ans[maxn];
inline void pushup(int k){for(int i=0;i<2;i++)xds[k].mn[i]=min(xds[xds[k].ls].mn[i],xds[xds[k].rs].mn[i]),xds[k].mx[i]=max(xds[xds[k].ls].mx[i],xds[xds[k].rs].mx[i]);}
inline void ADD(int k,int v){xds[k].tag+=v;}
inline void pushdown(int k){ADD(xds[k].ls,xds[k].tag),ADD(xds[k].rs,xds[k].tag),xds[k].tag=0;}
#define mid ((l+r)>>1)

void dfs(int k,int l,int r){
	if(l==r)return ans[xds[k].id]+=xds[k].ans,void();
	xds[xds[k].ls].ans+=xds[k].ans;xds[xds[k].rs].ans+=xds[k].ans;
	dfs(xds[k].ls,l,mid);dfs(xds[k].rs,mid+1,r);
}
inline int pd(int k,line Q){
	int res=0;
	res+=(Q(xds[k].mn[0],xds[k].mn[1])>0);
	res+=(Q(xds[k].mn[0],xds[k].mx[1])>0);
	res+=(Q(xds[k].mx[0],xds[k].mn[1])>0);
	res+=(Q(xds[k].mx[0],xds[k].mx[1])>0);
	return res;
}
bool vis[maxn<<2];
void modify(int k,line Q){
	int z=pd(k,Q);
	vis[k]=1;
	if(z==0)return ;
	if(z==4){
		// cerr<<"ADD "<<k<<" "<<1<<endl;
		return ADD(k,1);
	}
	pushdown(k);
	modify(xds[k].ls,Q);modify(xds[k].rs,Q);
}
struct pt{int id;db x,y;}cp[maxn];
bool cmpx(pt a,pt b){return a.x<b.x;}
bool cmpy(pt a,pt b){return a.y<b.y;}
int cnt=0;
void build(int &k,int l,int r,int d){
	k=++cnt;
	xds[k].tag=xds[k].ans=0;
	if(l==r){
		xds[k].mn[0]=xds[k].mx[0]=cp[l].x,xds[k].mn[1]=xds[k].mx[1]=cp[l].y;
		xds[k].ls=xds[k].rs=0,xds[k].id=cp[l].id;
		return ;
	}
	nth_element(cp+l,cp+mid,cp+r,d?cmpx:cmpy);
	build(xds[k].ls,l,mid,d^1);build(xds[k].rs,mid+1,r,d^1);
	pushup(k);
	// cerr<<k<<" -> "<<xds[k].ls<<","<<xds[k].rs<<endl;
}
void dfs2(int k){
	if(!vis[xds[k].ls]&&!vis[xds[k].rs]){
		// cerr<<k<<" ans updated by "<<xds[k].tag*xds[k].tag<<endl;
		return xds[k].ans+=xds[k].tag*xds[k].tag,xds[k].tag=0,vis[k]=0,void();
	}
	pushdown(k);
	dfs2(xds[k].ls);dfs2(xds[k].rs);vis[k]=0;
}
int n,m;
vector<line> e[maxn];
struct lxl_dick_sucker{
	pair<db,int> p[maxn],L[maxn];
	int tot,cntc[maxn],cur;
	lxl_dick_sucker(){cur=tot=0;}
	void solve(){
		if(!tot)return ;
		sort(p+1,p+n+1);sort(L+1,L+tot+1);
		int now=0;
		for(int i=1;i<=tot;i++){
			while(now+1<=n&&p[now+1].first<L[i].first){
				++now;int &t=cntc[p[now].second];t++;
				cur+=t*t-(t-1)*(t-1);
			}
			ans[L[i].second]=cur;
		}
	}
}T[2];
struct lxl_ass_kicker{
	pt p[maxn];
	int tot,tp,rt;
	lxl_ass_kicker(){tot=0;}
	void solve(){
		if(!tot)return ;
		cnt=0;
		for(int i=1;i<=tot;i++)cp[i]=p[i];
		build(rt,1,tot,0);
		for(int i=1;i<=n;i++){
			// cerr<<"___________________________"<<endl;
			for(auto [A,B,C]:e[i]){
				A*=tp,B*=tp,C*=tp;
				// cerr<<"Line : "<<A<<" "<<B<<" "<<C<<endl;
				modify(rt,{A,B,C});
			}
			dfs2(rt);
		}
		dfs(rt,1,tot);
	}
}P[2];
signed main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		int x,y,c;cin>>x>>y>>c;
		e[c].push_back({y,1,x});
		T[0].p[i]={y,c};
		T[1].p[i]={-y,c};
	}
	P[0].tp=-1;P[1].tp=1;
	for(int i=1;i<=m;i++){
		int A,B,C;cin>>A>>B>>C;
		if(A==0){
			if(B>0)T[0].L[++T[0].tot]={frac(-C,B),i};
			else T[1].L[++T[1].tot]={frac(C,B),i};
		}else{
			if(A>0)P[0].p[++P[0].tot]={i,frac(B,A),1.0*frac(C,A)};
			else P[1].p[++P[1].tot]={i,frac(B,A),1.0*frac(C,A)};
		}
	}
	T[0].solve(),T[1].solve();
	P[0].solve();P[1].solve();
	for(int i=1;i<=m;i++)cout<<ans[i]<<endl;
	return 0;
}