Problem: In 20XX AD, a school competition was held. The tournament has finally left only the final competition. You are one of the athletes in the competition.

The competition you participate in is to compete for the time it takes to destroy all the blue objects placed in the space. Athletes are allowed to bring in competition guns. In the space, there are multiple blue objects, the same number of red objects, and multiple obstacles. There is a one-to-one correspondence between the blue object and the red object, and the blue object must be destroyed by shooting a bullet at the blue object from the coordinates where the red object is placed. The obstacles placed in the space are spherical and the composition is slightly different, but if it is a normal bullet, the bullet will stop there when it touches the obstacle.

The bullet used in the competition is a special bullet called Magic Bullet. This bullet can store magical power, and when the bullet touches an obstacle, it automatically consumes the magical power, and the magic that the bullet penetrates is activated. Due to the difference in the composition of obstacles, the amount of magic required to penetrate and the amount of magic power consumed to activate it are different. Therefore, even after the magic for one obstacle is activated, it is necessary to activate another magic in order to penetrate another obstacle. Also, if the bullet touches multiple obstacles at the same time, magic will be activated at the same time. The amount of magical power contained in the bullet decreases with each magic activation.

While the position and size of obstacles and the amount of magical power required to activate the penetrating magic have already been disclosed, the positions of the red and blue objects have not been disclosed. However, the position of the object could be predicted to some extent from the information of the same competition in the past. You want to save as much magical power as you can, because putting magical power into a bullet is very exhausting. Therefore, assuming the position of the red object and the corresponding blue object, the minimum amount of magical power required to be loaded in the bullet at that time, that is, the magical power remaining in the bullet when reaching the blue object is 0. Let's find the amount of magical power that becomes.

Constraints

* 0 ≤ N ≤ 50
* 1 ≤ Q ≤ 50
* -500 ≤ xi, yi, zi ≤ 500
* 1 ≤ ri ≤ 1,000
* 1 ≤ li ≤ 1016
* -500 ≤ sxj, syj, szj ≤ 500
* -500 ≤ dxj, dyj, dzj ≤ 500
* Obstacles are never stuck in other obstacles
* The coordinates of the object are not inside or on the surface of the obstacle
* Under each assumption, the coordinates of the red object and the blue object do not match.

Input

All inputs are integers. Each number is separated by a single space.


N Q
x1 y1 z1 r1 l1
::
xN yN zN rN lN
sx1 sy1 sz1 dx1 dy1 dz1
::
sxQ syQ szQ dxQ dyQ dzQ


* N is the number of obstacles, and Q is the number of coordinates of the assumed blue and red objects.
* xi, yi, and zi are the x-coordinate, y-coordinate, and z-coordinate that represent the position of the center of the i-th obstacle, respectively.
* ri is the radius of the i-th obstacle.
* li is the amount of magical power consumed by magic to penetrate the i-th obstacle.
* sxj, syj, and szj are the x-coordinate, y-coordinate, and z-coordinate that represent the position of the red object in the jth assumption, respectively.
* dxj, dyj, and dzj are the x-coordinate, y-coordinate, and z-coordinate that represent the position of the blue object in the jth assumption, respectively.

Output

Assuming the position of each pair of red objects and the corresponding blue objects, the amount of magical power to be loaded in the bullet is output on one line, assuming that there are only obstacles, red objects, and one pair of blue objects in space. Let's do it. The bullet is supposed to fly in a straight line from the position of the red object to the position of the blue object, and since the size of the bullet is very small, it is treated as a point.

Examples

Input

5 1
0 10 0 5 2
0 20 0 5 12
0 30 0 5 22
0 40 0 5 32
0 50 0 5 42
0 0 0 0 60 0


Output

110


Input

1 1
10 5 0 5 9
0 0 0 9 12 0


Output

9


Input

5 5
-38 -71 -293 75 1
-158 -38 -405 66 1
-236 -303 157 266 1
316 26 411 190 1
207 -312 -27 196 1
-50 292 -375 -401 389 -389
460 278 409 -329 -303 411
215 -220 -200 309 -474 300
261 -494 -87 -300 123 -463
386 378 486 -443 -64 299


Output

0
2
1
3
0

Solution (in CPP):

Solution:
#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();
}