#include <bits/stdc++.h>
using namespace std;

// *geometry library

typedef double Real;
constexpr Real EPS = 1e-10;
const Real PI = acos((Real)-1);
inline int sign(Real d) { return d > EPS ? 1 : d < -EPS ? -1 : 0; }

struct Point {
	Real x, y;
	constexpr explicit Point(Real x_ = 0, Real y_ = 0):x(x_), y(y_) {}
	Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
	Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
	Point operator*(const Point &p) const { return Point(x * p.x - y * p.y, x * p.y + y * p.x); }
	Point operator*(Real s) const { return Point(x * s, y * s); }
	Point operator/(Real s) const { return Point(x / s, y / s); }
	bool operator<(const Point &p) const { return sign(x - p.x) == -1 || (sign(x - p.x) == 0 && sign(y - p.y) == -1); }
	bool operator==(const Point &p) const { return sign(x - p.x) == 0 && sign(y - p.y) == 0; }
};

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

inline ostream &operator<<(ostream &os, const Point &p) {
	return os << '(' << p.x << ", " << p.y << ')';
}

inline Point rotate(const Point &p, Real theta) {
	const Real s = sin(theta), c = cos(theta);
	return Point(c * p.x - s * p.y, s * p.x + c * p.y);
}

inline Real norm(const Point &p) {
	return p.x * p.x + p.y * p.y;
}

inline Real cross(const Point &a, const Point &b) {
	return a.x * b.y - a.y * b.x;
}

// ??????????§??????¨??????????????????a, b, c???????????????
// c??????a??????b??????????¨?????????§???????§????????????¨?????????????????¨?????????????????????
// + : ?????¨
// 0 : ?????? or A = B
// - : ?????¨
inline int judge(const Point &a, const Point &b, const Point &c) {
	return sign(cross(a, c)) - sign(cross(b, c)) - sign(cross(a, b));
}

// *solve

inline bool check(const Point &house, const Point &flower, Real d, Real w, Real a) {
	const auto vec = house - flower;
	if(sign(norm(vec) - a * a) == 1) return false;
	return judge(rotate(Point(1, 0), w - d * 0.5), rotate(Point(1, 0), w + d * 0.5), vec) >= 0;
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
	cout.setf(ios::fixed);
	cout.precision(10);

	constexpr Point mine(0, 0);
	for(int h, r; cin >> h >> r && h;) {
		vector<Point> houses(h);
		for(auto &p : houses) cin >> p;

		int u, m, s;
		Real du, dm, ds;
		cin >> u >> m >> s >> du >> dm >> ds;
		du = du / 180 * PI;
		dm = dm / 180 * PI;
		ds = ds / 180 * PI;

		vector<Point> ume(u), matsu(m), sakura(s);
		for(auto &p : ume) cin >> p;
		for(auto &p : matsu) cin >> p;
		for(auto &p : sakura) cin >> p;

		vector<int> cnt(h, 0);
		for(int _ = 0; _ < r; ++_) {
			Real w, a;
			cin >> w >> a;
			w = w / 180 * PI;
			for(int i = 0; i < h; ++i) {
				const auto &p = houses[i];
				bool ok = check(p, mine, du, w, a);
				for(const auto &e : ume) if(ok) ok = !check(p, e, du, w, a);
				for(const auto &e : matsu) if(ok) ok = !check(p, e, dm, w, a);
				for(const auto &e : sakura) if(ok) ok = !check(p, e, ds, w, a);
				if(ok) ++cnt[i];
			}
		}

		const int mx = *max_element(begin(cnt), end(cnt));
		if(mx == 0) {
			cout << "NA\n";
			continue;
		}

		bool first = true;
		for(int i = 0; i < h; ++i) {
			if(cnt[i] == mx) {
				if(first) {
					first = !first;
				}
				else {
					cout << ' ';
				}
				cout << i + 1;
			}
		}
		cout << '\n';
	}

	return EXIT_SUCCESS;
}

Measured memory_bytes: 1252