#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <list>
#include <vector>
#include <complex>
#include <utility>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <bitset>
#include <ctime>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cassert>
#include <cstddef>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <sstream>
#include <fstream>

using namespace std;
#define REP(i, n) for (int (i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int (i) = (a); (i) < (b); (i)++)
#define RREP(i, a) for(int (i) = (a) - 1; (i) >= 0; (i)--)
#define FORR(i, a, b) for(int (i) = (a) - 1; (i) >= (b); (i)--)
#define DEBUG(C) cerr << #C << " = " << C << endl;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<LL>;
using VVL = vector<VL>;
using VD = vector<double>;
using VVD = vector<VD>;
using PII = pair<int, int>;
using PDD = pair<double, double>;
using PLL = pair<LL, LL>;
using VPII = vector<PII>;
template<typename T> using VT = vector<T>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) rbegin((a)), rend((a))
#define SORT(a) sort(ALL((a)))
#define RSORT(a) sort(RALL((a)))
#define REVERSE(a) reverse(ALL((a)))
#define MP make_pair
#define FORE(a, b) for (auto &&a : (b))
#define FIND(s, e) ((s).find(e) != (s).end())
#define EB emplace_back
template<typename T>inline bool chmax(T &a,T b){if(a<b){a=b;return true;}return false;}
template<typename T>inline bool chmin(T &a,T b){if(a>b){a=b;return true;}return false;}

const int INF = 1e9;
const int MOD = INF + 7;
const LL LLINF = 1e18;

namespace Geometry3D {
    const long double EPS = 1e-10;
    double add(double a, double b) {
        if (abs(a + b) < Geometry3D::EPS * (abs(a) + abs(b))) return 0;
        return a + b;
    }
    int sgn(double a, double b = 0.0) {// sign function
        return a < b - EPS ? -1 : a > b + EPS ? 1 : 0;
    }

    struct Point {
        double x, y, z;
        Point() {}
        Point(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}
        const Geometry3D::Point operator+ (const Geometry3D::Point &p) {
            return Point(Geometry3D::add(this->x, p.x), Geometry3D::add(this->y, p.y), Geometry3D::add(this->z, p.z));
        }
        const Geometry3D::Point operator- (const Geometry3D::Point &p) {
            return Point(Geometry3D::add(this->x, -p.x), Geometry3D::add(this->y, -p.y), Geometry3D::add(this->z, -p.z));
        }
        const Geometry3D::Point operator* (double d) {
            return Point(this->x * d, this->y * d, this->z * d);
        }
        double norm() { //????????¨???????±????????????????????????¶?????????2???
            return this->x * this->x + this->y * this->y + this->z * this->z;
        }
        double distance() {
            return sqrt(this->norm());
        }
    };

    double naiseki(const Geometry3D::Point &p1, const Geometry3D::Point &p2) {
        return p1.x * p2.x + p1.y * p2.y + p1.z * p2.z;
    }
    Geometry3D::Point gaiseki(const Geometry3D::Point &p1, const Geometry3D::Point &p2) {
        return Geometry3D::Point(p1.y * p2.z - p2.y * p1.z, -(p1.x * p2.z - p2.x * p1.z), p1.x * p2.y - p2.x * p1.y);
    }

    struct Line {
        Geometry3D::Point a, b, dis;
        Line() {}
        Line(const Geometry3D::Point &_a, const Geometry3D::Point &_b) : a(_a), b(_b), dis(b - a) {}
        double distSquare() {
            const double X = this->a.x - this->b.x;
            const double Y = this->a.y - this->b.y;
            const double Z = this->a.z - this->b.z;
            return X * X + Y * Y + Z * Z;
        }
        double distance() {
            return this->distSquare();
        }
    };
    using Segment = Geometry3D::Line;

    double distanceLineToPoint(Geometry3D::Line &l, Geometry3D::Point &p) {
        return Geometry3D::gaiseki(l.dis, p - l.a).distance() / l.dis.distance();
    }

    double distanceSegmentToPoint(Geometry3D::Segment &l, Geometry3D::Point &p) {
        if (Geometry3D::naiseki(l.b - l.a, p - l.a) < 0) {
            auto buf = p - l.a;
            return buf.distance();
        }
        if (Geometry3D::naiseki(l.a - l.b, p - l.b) < 0) {
            auto buf = p - l.b;
            return buf.distance();
        }
        return Geometry3D::distanceLineToPoint(l, p);
    }

    struct Ball {
        Geometry3D::Point center;
        double r;
        Ball() {}
        Ball(double _x, double _y, double _z, double _r) : center(_x, _y, _z), r(_r) {}
        Ball(const Geometry3D::Point &_c, double _r) : center(_c), r(_r) {}
        bool inside(const Geometry3D::Point &p) {
            const double X = p.x - this->center.x;
            const double Y = p.y - this->center.y;
            const double Z = p.z - this->center.z;
            return sgn(X * X + Y * Y + Z * Z, -(this->r * this->r)) == -1;
        }
        bool inside(Geometry3D::Segment &s) {
            return Geometry3D::sgn(Geometry3D::distanceSegmentToPoint(s, this->center) - this->r) == -1;
        }
        bool on_seg(const Geometry3D::Point &p) {
            const double X = p.x - this->center.x;
            const double Y = p.y - this->center.y;
            const double Z = p.z - this->center.z;
            return sgn(X * X + Y * Y + Z * Z, -(this->r * this->r)) == 0;
        }
        bool on_seg(Geometry3D::Segment &s) {
            return Geometry3D::sgn(Geometry3D::distanceSegmentToPoint(s, this->center) - this->r) == 0;
        }
    };
};

void init();
void last();

void init() {

}

using Geometry3D::Point;
using Geometry3D::Segment;
using Geometry3D::Ball;
const int MAX = 55;
pair<Ball, long long> ball[MAX];
Segment seg[MAX];
void solve(int n, int q) {
    for (int i = 0; i < n; i++) {
        int x, y, z, r;
        long long l;
        scanf("%d%d%d%d%lld", &x, &y, &z, &r, &l);
        ball[i] = make_pair(Ball(Point(x, y, z), r), l);
    }
    for (int i = 0; i < q; i ++) {
        int sx, sy, sz, dx, dy, dz;
        scanf("%d%d%d%d%d%d", &sx, &sy, &sz, &dx, &dy, &dz);
        seg[i] = Segment(Point(sx, sy, sz), Point(dx, dy, dz));
    }
    for (int i = 0; i < q; i++) {
        long long ans = 0;
        for (int j = 0; j < n; j++) {
            if (ball[j].first.on_seg(seg[i]) || ball[j].first.inside(seg[i])) {
                ans += ball[j].second;
            }
        }
        printf("%lld\n", ans);
    }
    exit(0);
}

void refresh() {

}

void last() {
    exit(0);
}

int main(void) {
	int a, b, c, x, y, z, n, m, p, k;
	string s;
	while (cin >> n >> m, n) {
		solve(n, m);
        refresh();
	}
    last();
}

Measured memory_bytes: 3228