// Problem: P8261 [CTS2022] 袜子
// URL: https://www.luogu.com.cn/problem/P8261
// Memory Limit: 512 MB
// Time Limit: 8000 ms
// Author: Nityacke
// Time: 2024-07-02 14:39:41

#include<bits/stdc++.h>
#define ll long long



#define db double



#define pb push_back



using namespace std;
const int N=5e5+5,M=5e4+5,INF=2e9;
bool Med;
int n,m;
ll ans[N];
struct pt{int x,y,c;}a[M];
vector<pt>G[M];
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



}
namespace Sub1{
	vector<pt>Q1,Q2;
	int cnt[M];
	ll res;
	inline void add(int x,int y,int c){
		if(x>0) Q1.pb({x,y,c});
		else Q2.pb({x,y,c});
	}
	inline void solve(){
		sort(a+1,a+n+1,[&](pt a,pt b){return a.y<b.y;});
		sort(Q1.begin(),Q1.end(),[&](pt a,pt b){return (-1.0*a.y/a.x)<(-1.0*b.y/b.x);});
		sort(Q2.begin(),Q2.end(),[&](pt a,pt b){return (-1.0*a.y/a.x)>(-1.0*b.y/b.x);});
		int idx=1;
		for(auto v:Q1){
			while(idx<=n&&1ll*v.x*a[idx].y+v.y<0) ++cnt[a[idx].c],res+=2*cnt[a[idx].c]-1,++idx;
			ans[v.c]=res;
		}
		for(int i=0;i<M;++i) cnt[i]=0;
		sort(a+1,a+n+1,[&](pt a,pt b){return a.y>b.y;});
		idx=1,res=0;
		for(auto v:Q2){
			while(idx<=n&&1ll*v.x*a[idx].y+v.y<0) ++cnt[a[idx].c],res+=2*cnt[a[idx].c]-1,++idx;
			ans[v.c]=res;
		}
	}
}
struct frac{
	ll a,b;
	inline frac(ll _a=1,ll _b=1){
		if(_b<0) _a=-_a,_b=-_b;
		a=_a,b=_b;
	}
	inline friend frac max(frac A,frac B){return A.a*B.b<B.a*A.b?B:A;}
	inline friend frac min(frac A,frac B){return A.a*B.b<B.a*A.b?A:B;}
	inline friend bool operator<(frac A,frac B){
		return A.a*B.b<B.a*A.b;
	}
	inline friend frac operator*(frac A,int b){
		return frac(A.a*b,A.b);
	}
	inline friend frac operator+(frac A,frac B){
		return frac(A.a*B.b+A.b*B.a,A.b*B.b);
	}
	inline friend frac operator+(frac A,int b){
		return frac(A.a+A.b*b,A.b);
	}
};
struct point{frac x,y;int id;};
vector<point>Vec;
int tot,rt;
struct Node{
	frac xl,xr,yl,yr;
	int id,tag,lc,rc;
	ll ans;
	inline void init(point a){xl=xr=a.x,yl=yr=a.y,id=a.id,tag=ans=lc=rc=0;}
}t[N<<1];
#define k1 t[k].lc



#define k2 t[k].rc



#define mid ((l+r)>>1)



inline bool cmpx(point A,point B){return A.x<B.x;}
inline bool cmpy(point A,point B){return A.y<B.y;}
inline void up(int k){
	t[k].xl=min(t[k1].xl,t[k2].xl),t[k].xr=max(t[k1].xr,t[k2].xr),
	t[k].yl=min(t[k1].yl,t[k2].yl),t[k].yr=max(t[k1].yr,t[k2].yr);
}
inline int build(int l,int r,int d=0){
	int k=++tot;
	t[k].ans=t[k].tag=t[k].id=0;
	if(l==r) return t[k].init(Vec[l]),k;
	nth_element(Vec.begin()+l,Vec.begin()+mid,Vec.begin()+r+1,d?cmpx:cmpy);
	k1=build(l,mid,d^1),k2=build(mid+1,r,d^1);
	return up(k),k;
}
int A,B,C,Cnt;
bool flag;
inline frac Mn(int k){
	frac now(C,1);
	if(A<=0) now=now+t[k].xr*A;
	else now=now+t[k].xl*A;
	if(B<=0) now=now+t[k].yr*B;
	else now=now+t[k].yl*B;
	return now;
}
inline frac Mx(int k){
	frac now(C,1);
	if(A>=0) now=now+t[k].xr*A;
	else now=now+t[k].xl*A;
	if(B>=0) now=now+t[k].yr*B;
	else now=now+t[k].yl*B;
	return now;
}
inline void dfs(int k,int l,int r){
	if(l==r) return ans[t[k].id]=t[k].ans,void();
	t[k1].ans+=t[k].ans,t[k2].ans+=t[k].ans;
	dfs(k1,l,mid),dfs(k2,mid+1,r);
}
inline void add(int k,int v){t[k].tag+=v;}
inline void push(int k){if(t[k].tag) add(k1,t[k].tag),add(k2,t[k].tag),t[k].tag=0;}
int vis[N<<1];
inline void change(int k){
	frac mx=Mx(k),mn=Mn(k);
	vis[k]=1,++Cnt;
	if((flag&&mx.a<0)||(!flag&&mn.a>0)) return add(k,1);
	if((flag&&mn.a>=0)||(!flag&&mx.a<=0)) return;
	push(k),change(k1),change(k2);
}
inline void calc(int k){
	if(!vis[k1]&&!vis[k2]) return t[k].ans+=1ll*t[k].tag*t[k].tag,vis[k]=t[k].tag=0,void();
	push(k),calc(k1),calc(k2),vis[k]=0;
}
namespace T1{
	vector<point>vec;
	inline void add(frac x,frac y,int id){vec.pb({x,y,id});}
	inline void solve(){
		int sz=(int)vec.size();
		if(!sz) return;
		flag=1,tot=0,Vec=vec,rt=build(0,sz-1);
		for(int i=1;i<=n;++i)
			if(G[i].size()){
				for(auto v:G[i]) A=1,B=v.y,C=v.x,change(1);
				calc(rt);
			}
		dfs(rt,0,sz-1);
	}
}
namespace T2{
	vector<point>vec;
	inline void add(frac x,frac y,int id){vec.pb({x,y,id});}
	inline void solve(){
		int sz=(int)vec.size();
		if(!sz) return;
		flag=0,tot=0,Vec=vec,rt=build(0,sz-1);
		for(int i=1;i<=n;++i)
			if(G[i].size()){
				for(auto v:G[i]) A=1,B=v.y,C=v.x,change(1);
				calc(rt);
			}
		dfs(rt,0,sz-1);
	}
}
bool Mst;
signed main(){
	cin>>n>>m;
	for(int i=1;i<=n;++i) cin>>a[i].x>>a[i].y>>a[i].c,G[a[i].c].pb({a[i].x,a[i].y,i});
	for(int A,B,C,i=1;i<=m;++i){
		cin>>A>>B>>C;
		if(!A) Sub1::add(B,C,i);
		else if(A>0) T1::add(frac(C,A),frac(B,A),i);
		else T2::add(frac(C,A),frac(B,A),i);
	}
	T1::solve(),T2::solve(),Sub1::solve(),cerr<<Cnt<<"\n";
	for(int i=1;i<=m;++i) cout<<ans[i]<<"\n";
}