#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
template <class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
template <class T> void org(T l, T r) { while (l != r) cerr << ' ' << *l++; cerr << '\n'; }
#define debug(x...) dbg(#x, '=', x, '\n')
#define olist(x...) dbg(#x, '='), org(x)
#else
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#define debug(...) ((void)0)
#define olist(...) ((void)0)
#endif
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using Pt = pair<int, int>;

template <class T> inline constexpr T inf = numeric_limits<T>::max() / 2;
constexpr int mod = 998244353;
constexpr double eps = 0;

template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }
template<class... T> int add(T... x) { int t{}; return (((t += x) %= mod), ...), t; }
template<class... T> int mul(T... x) { i64 t{1}; return (((t *= x) %= mod), ...), t; }

int sig(double x) { return (x > eps) - (x < -eps); }

struct Cir {
    i64 x, y, r, id, type;
    double get(double t) const {
        return y + type * sqrt(r * r - (x - t) * (x - t));
    }
};

void solve() {
    int n, q;
    cin >> n >> q;

    const int m = n + q;
    vector<array<int, 3>> C(m);
    vector<pair<int, int>> event;
    for (int i = 0; i < m; i++) {
        int x, y, r;
        cin >> x >> y >> r;
        C[i] = {x, y, r};
        event.emplace_back(x - r, i + m);
        event.emplace_back(x + r, i);
    }

    sort(all(event));

    int curx = -3e7;
    auto cmp = [&](const Cir &a, const Cir &b) -> bool {
        double s = a.get(curx), t = b.get(curx);
        if (sig(s - t) == 0) return a.type == b.type ? a.id < b.id : a.type < b.type;
        return s < t;
    };
    
    vector<int> pa(m, -1);
    vector G(m, vector<int>{});
    set<Cir, decltype(cmp)> S(cmp);
    for (auto [x, id] : event) {
        curx = x;
        
        Cir up{C[id % m][0], C[id % m][1], C[id % m][2], id % m, 1};
        Cir low{C[id % m][0], C[id % m][1], C[id % m][2], id % m, -1};

        if (id >= m) { // add
            id -= m;
            auto it = S.lower_bound(up);
            if (it != S.end() and it->type == 1) {
                int f = it->id;
                G[f].push_back(id);
                pa[id] = f;
            } else if (it != S.end() and it->type == -1) {
                int f = pa[it->id];
                if (f != -1) {
                    G[f].push_back(id);
                    pa[id] = f;
                }
            }
            S.insert(up);
            S.insert(low);
        } else { // del
            S.erase(up);
            S.erase(low);
        }

    }

    for (int i = 0; i < m; i++) {
        debug(i);
        olist(all(G[i]));
    }

    vector<bool> vis(m);
    vector dp(m, array<int, 2>{});
    auto dfs = [&](auto self, int u) -> void {
        if (vis[u]) return;
        vis[u] = 1;
        for (int v : G[u]) {
            self(self, v);
            if (u < n) {
                dp[u][0] += max(dp[v][0], dp[v][1]);
                dp[u][1] += dp[v][0];
            } else {
                dp[u][0] += dp[v][0];
                dp[u][1] += max(dp[v][0], dp[v][1]);
            }
        }
        if (u < n) dp[u][1] += 1;
    };
    for (int i = 0; i < m; i++)
        if (!vis[i]) dfs(dfs, i);

    for (int i = n; i < n + q; i++) {
        cout << max(dp[i][0] + 1, dp[i][1]) << '\n';
    }
} 

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}