#include <bits/stdc++.h>
  
using namespace std;
  
#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define repr(i, n) REPR(i, n, 0)
#define REPR(i, s, e) for(int i=(int)(s-1); i>=(int)(e); i--)
#define pb push_back
#define all(r) r.begin(),r.end()
#define rall(r) r.rbegin(),r.rend()
#define fi first
#define se second
  
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

// #define DEBUG_MODE
#ifdef DEBUG_MODE
#define dump(x) cout << #x << " : " << x << endl
#define LINE cout << "line : " << __LINE__ << endl
#define dumpV(v) cout << #v << " : ["; for(auto& t : v) cout << t << ", "; cout<<"]" << endl
#define STOP assert(false)
#else
#define dump(x) ;
#define LINE     ;
#define dumpV(v);
#define STOP     ;
#endif
#define mp make_pair

namespace std{
  template<class S,class T>
  ostream &operator <<(ostream& out,const pair<S,T>& a){
    out<<'('<<a.fi<<", "<<a.se<<')';
    return out;
  }
}

 
typedef double D;
namespace std {
    const D EPS = 1e-10;
    using P = valarray<D>;
    const P Origin = {(D)0.0, (D)0.0, (D)0.0};
    #define x(P) (P)[0]
    #define y(P) (P)[1]
    #define z(P) (P)[2]
    #define SQ(Q) ((Q)*(Q))

    bool operator < (const P& a, const P& b) {
        if(x(a) != x(b)) return x(a) < x(b);
        if(y(a) != y(b)) return y(a) < y(b);
        return z(a) < z(b);
    }
}


struct L : array<P, 2> {
    L() {at(0) = at(1) = Origin;}
    L(const P& a, const P& b) {
        at(0) = a;
        at(1) = b;
    }
};
D dot(const P& a, const P& b) {
    auto p = a*b;
    return p.sum();
}
P cross(const P& a, const P& b) {
    P ret(3);
    x(ret) = y(a) * z(b) - y(b) * z(a);
    y(ret) = z(a) * x(b) - z(b) * x(a);
    z(ret) = x(a) * y(b) - x(b) * y(a);
    return ret;
}
D norm(const P& p) {
    return sqrt(dot(p, p));
}
bool isHitLP(const L&l ,const P& p) {
    P v = l[1] - l[0], v1 = p - l[0];
    return abs(norm(cross(v, v1))) < EPS;
}
bool isHitSP(const L& l, const P& p) {
    P v = l[1] - l[0], v1 = p - l[0];
    P u = l[0] - l[1], u1 = p - l[1];
    return abs(norm(cross(v, v1))) < EPS && norm(v1) < norm(v) + EPS
            && abs(norm(cross(u, u1))) < EPS && norm(u1) < norm(u) + EPS; 
}
D distLP(const L& l, const P& p) {
    if(isHitLP(l, p)) return (D)0.0;
    P AB = l[1] - l[0];
    P AP = p - l[0];
    if(abs(norm(AB)) < EPS) return norm(AP);
    return norm(cross(AB, AP)) / norm(AB);
}
D distSP(const L& l, const P& p) {
    if(isHitSP(l, p)) return (D)0.0;
    return min({norm(p - l[0]), norm(p - l[1]), distLP(l, p)});
}
struct C{
    P p;
    D r;
};
bool isHitPC(const P& p, const C& c) {
    return norm(p - c.p) < c.r + EPS;
}
vector<P> crossPointLC(const L&l ,const C& cir) {
    P s = l[0] - cir.p;
    P d = l[1] - l[0];
    auto A = dot(d, d), B = dot(d, s), C = dot(s, s) - SQ(cir.r);
    auto DD = (SQ(B) - A * C);
    vector<D> t;
    if(abs(DD) < 0) t.pb(B / A);
    else if(DD < 0) ;
    else {
        t.pb((-B + sqrt(DD)) / A);
        t.pb((-B - sqrt(DD)) / A);
    }
    vector<P> ret;
    rep(i, t.size()) ret.push_back(s + d * t[i]);
    rep(i, ret.size()) ret[i] += cir.p;
    return ret;
}
vector<P> crossPointSC(const L&l ,const C& c) {
    vector<P> ps = crossPointLC(l, c);
    sort(all(ps));
    auto it = ps.begin();
    while(it != ps.end()) {
        assert(abs(norm(*it - c.p) - c.r) < EPS);
        if(isHitSP(l, *it)) ++it;
        else it = ps.erase(it);
    }
    return ps;
}
bool isHitLC(const L& l, const C& c) {
    return distLP(l, c.p) < c.r + EPS;
}
bool isHitSC(const L& l, const C& c) {
    // if(!isHitLC(l, c)) return false;
    return crossPointSC(l, c).size() > 0;
}


int main(){
    int n, q;
    cin >> n >> q;
    vector<C> cs(n);
    vector<ll> costs(n);
    LINE;
    rep(i, n) {
        D x, y, z, r;
        cin >> x >> y >> z >> r >> costs[i];
        cs[i] = {P{x, y, z}, r};
    }
    LINE;
    auto calc = [&](const P& a, const P& b) {
        ll ret = 0LL;
        rep(i, n) {
            L l(a, b);
            if(isHitSC(l, cs[i])) {
                dump(i);
                dump(distSP(l, cs[i].p));
                auto ps = crossPointSC(l, cs[i]);
                dump(ps.size());
                for(auto& p : ps) {
                    dumpV(p);
                }
                auto ps2 = crossPointLC(l, cs[i]);
                dump(ps2.size());
                for(auto& p : ps2) {
                    dumpV(p);
                }
                ret += costs[i];
            }
        }
        return ret;
    };
    rep(i, q) {
        D x, y, z;
        cin >> x >> y >> z;
        P s = {x, y, z};
        cin >> x >> y >> z;
        P t = {x, y, z};
        cout << calc(s, t) << endl;
    }
    return 0;
}


Measured memory_bytes: 3304