Problem: Klein is trying to get her dog Jack into the Frisbee Dog Tournament. But she's not sure if Jack will get a good grade. For her, she simulates the tournament to get Jack's grade. I want you to create a program to estimate.

The tournament is held by N dogs on a two-dimensional plane. At the start of the tournament, the i-th dog is in the (Dix, Diy) position. The i-th dog is Vi [m / s] All dogs are small enough to be considered points. At any given time, two or more dogs may be in the same position.

The tournament begins with the launch of the first Frisbee, from which the dogs are allowed to move. Frisbee can also be considered a point, the i Frisbee from the (FPix, FPiy) position ( FVix, FViy) Fired at a velocity vector of [m / s] and continues a constant velocity linear motion. When a dog's position and a Frisbee's position are equal, the dog can get a Frisbee.

The moment the first Frisbee is acquired by one of the dogs, the second Frisbee is fired. The moment the second Frisbee is acquired, the third is fired, and so on. Immediately after, the next Frisbee will be fired. The tournament will end when the Mth Frisbee is acquired.

Needless to say, the dogs' goal is to get more Frisbee. Dogs take the following strategies.

When the Frisbee is fired, the dog moves to get it at the earliest possible time and gets the Frisbee. However, if it cannot get the Frisbee, it waits where it is.

The determination of whether a dog can get a frisbee is made regardless of the behavior of the other dog. That is, one dog moves to get a frisbee, but the other dog gets it first. The moment one of the dogs gets the Frisbee and a new Frisbee is launched, the dogs take the above strategy against the new Frisbee.

The program you create must output the number of Frisbees obtained by each dog.



Input

The input file consists of multiple datasets.

The first row of the dataset gives the number of dogs N (1 ≤ N ≤ 10) and the number of Frisbees M (1 ≤ M ≤ 1000).

The following N lines are given the dog's initial position and velocity Dix, Diy, Vi, separated by a single blank.

The following M lines are given the Frisbee launch position and velocity FPix, FPiy, FVix, FViy, separated by a single space character.

The coordinate values ​​given are real numbers and their absolute values ​​do not exceed 1000. The speeds given are real numbers 1 ≤ DVi ≤ 100, -25 ≤ FVix, FViy ≤ 25. Frisbees that cannot be obtained by any dog You can assume that there is no.

When a dog with any Frisbee was obtained at time t, no dog could get it before time t + 1e-6.

During the simulation, the absolute values ​​of the dog's x and y coordinates do not exceed 1e + 8.

When both N and M are 0, the end of input is indicated.

Output

Output the number of Frisbees obtained by each dog on one line separated by a space character. The order of output must be the same as the order given in the input.

Example

Input

2 1
12 5 3
0 17 3
0 0 2 2
2 3
2 0 2
100 100 2
0 0 -1 0
-2 -5 0 3
100 100 1 1
0 0


Output

1 0
2 1

Solution (in CPP):

Solution:
#include <algorithm>
#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>
#include <tuple>
#include <assert.h>

#define sqr(x) std::pow(x, 2.0)
#define INF 1e10
#define REP(i, n) for (int i = 0; i < n; i++)
#define POS_OR_INF(x) (x > 0 ? x : INF)

using namespace std;

struct Point {
	double x;
	double y;
};

inline istream& operator >> (istream& is, Point& p) {
	return is >> p.x >> p.y;
}

typedef Point Vector;

struct Dog {
	Point  position;
	double speed;
};

inline std::pair<double, double> solve(const Dog& dog, const Point& fp, const Vector& fv) {
	Vector d = { fp.x - dog.position.x, fp.y - dog.position.y };

	double a = fv.x * fv.x + fv.y * fv.y - dog.speed * dog.speed;
	double b = d.x * fv.x + d.y * fv.y;
	double c = d.x * d.x + d.y * d.y;
	double det = b * b - a * c;

	if (det < 0) return make_pair(INF, INF);

	double t1 = (-b + sqrt(det)) / a;
	double t2 = (-b - sqrt(det)) / a;
	double t  = min(POS_OR_INF(t1), POS_OR_INF(t2));

	if (t < 0 || t == INF) return make_pair(INF, INF);

	double rad = atan2(d.y + fv.y * t, d.x + fv.x * t);

	// check
	//double xf = fp.x + fv.x * t; double xd = d.position.x + d.speed * t * cos(rad);
	//double yf = fp.y + fv.y * t; double yd = d.position.y + d.speed * t * sin(rad);

	return make_pair(t, rad);
}


int main(int argc, char** argv) {
	while (1) {
		int N, M;
		cin >> N >> M;

		if (N == 0 && M == 0) break;

		vector<Dog> dogs(N);
		vector<int> frisbees(N);

		REP(i, N)
			cin >> dogs[i].position >> dogs[i].speed;

		REP(i, M) {
			Point fp, fv;
			vector<double> t(N), rad(N);

			cin >> fp >> fv;

			REP(j, N)
				tie(t[j], rad[j]) = solve(dogs[j], fp, fv);

			auto best = min_element(t.begin(), t.end());

			frisbees[best - t.begin()]++;

			// move dogs
			REP(j, N) {
				if (t[j] == INF) continue;
				dogs[j].position.x += dogs[j].speed * cos(rad[j]) * *best;
				dogs[j].position.y += dogs[j].speed * sin(rad[j]) * *best;
			}
		}

		REP(i, N)
			cout << frisbees[i] << (i == N - 1 ? "\n" : " ");
	}
}