#include <bits/stdc++.h>
using namespace std;
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define PI 3.141592653589793238

struct Point3D
{
  long double x, y, z;
  Point3D() {}
  Point3D(long double x, long double y, long double z) : x(x), y(y), z(z) {}
  Point3D operator+(Point3D p) { return Point3D(x + p.x, y + p.y, z + p.z); }
  Point3D operator-(Point3D p) { return Point3D(x - p.x, y - p.y, z - p.z); }
  Point3D operator*(long double k) { return Point3D(x * k, y * k, z * k); }
  Point3D operator/(long double k) { return Point3D(x / k, y / k, z / k); }
  Point3D operator*(Point3D p)
  {
    return Point3D(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);
  }
  long double operator^(Point3D p)
  {
    return x * p.x + y * p.y + z * p.z;
  }
  long double norm() { return x * x + y * y + z * z; }
  long double abs() { return sqrt(norm()); }
  bool operator<(const Point3D &p) const
  {
    if (x != p.x)
      return x < p.x;
    if (y != p.y)
      return y < p.y;
    return z < p.z;
  }
  bool operator==(const Point3D &p) const
  {
    return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS && fabs(z - p.z) < EPS;
  }
};
istream &operator>>(istream &is, Point3D &p)
{
  is >> p.x >> p.y >> p.z;
  return is;
}
ostream &operator<<(ostream &os, Point3D p)
{
  os << fixed << setprecision(12) << p.x << " " << p.y << " " << p.z;
  return os;
}
typedef Point3D Vector3D;
typedef vector<Point3D> Polygon3D;

struct Segment3D
{
  Point3D p1, p2;
  Segment3D() {}
  Segment3D(Point3D p1, Point3D p2) : p1(p1), p2(p2) {}
};
typedef Segment3D Line3D;

istream &operator>>(istream &is, Segment3D &s)
{
  is >> s.p1 >> s.p2;
  return is;
}

struct Sphere
{
  Point3D c;
  long double r;
  Sphere() {}
  Sphere(Point3D c, long double r) : c(c), r(r) {}
};

istream &operator>>(istream &is, Sphere &c)
{
  is >> c.c >> c.r;
  return is;
}

long double norm(Vector3D a)
{
  return a.x * a.x + a.y * a.y + a.z * a.z;
}
long double abs(Vector3D a)
{
  return sqrt(norm(a));
}
long double dot(Vector3D a, Vector3D b)
{
  return a.x * b.x + a.y * b.y + a.z * b.z;
}
Vector3D cross(Vector3D a, Vector3D b)
{
  return Vector3D(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
}

long double getDistanceLP(Line3D l, Point3D p)
{
  return abs(cross(l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}

long double getDistanceSP(Segment3D s, Point3D p)
{
  if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
    return abs(p - s.p1);
  if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
    return abs(p - s.p2);
  return getDistanceLP(s, p);
}

bool intersectSC(Segment3D s, Sphere c)
{
  long double d = getDistanceSP(s, c.c);
  if (d > c.r)
    return 0;
  return !((abs(s.p1 - c.c) <= c.r) && (abs(s.p2 - c.c) <= c.r));
}

int main()
{
  cout << fixed << setprecision(20);
  int N, Q;
  cin >> N >> Q;
  vector<Sphere> vec(N);
  vector<unsigned long long> l(N);
  for (int i = 0; i < N; i++)
  {
    long double x, y, z, r;
    cin >> x >> y >> z >> r >> l[i];
    vec[i] = Sphere(Point3D(x, y, z), r);
  }

  for (int i = 0; i < Q; i++)
  {
    long double sx, sy, sz, dx, dy, dz;
    cin >> sx >> sy >> sz >> dx >> dy >> dz;

    Segment3D seg = Segment3D(Point3D(sx, sy, sz), Point3D(dx, dy, dz));
    unsigned long long ans = 0;
    for (int j = 0; j < N; j++)
    {
      if (intersectSC(seg, vec[j]))
      {
        ans += l[j];
      }
      //cout << vec[j].c << endl;
    }
    cout << ans << endl;
  }
  return 0;
}


Measured memory_bytes: 3224