#include <iostream>
#include <cassert>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <complex>
#include <cmath>

using namespace std;
typedef long long ll;

typedef long double R;
typedef complex<R> P;

namespace std {
    bool operator < (P a, P b) {
        return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
    }
    bool operator > (P a, P b) {
        return (b < a);
    }
}

const R EPS = 1e-10;
const R PI = acos((R)(-1));

/*
 -1 -> neg
  0 -> near 0
  1 -> pos
  */
int sgn(R a) {
    if (a < -EPS) return -1;
    if (a > EPS) return 1;
    return 0;
}

int sgn(R a, R b) {
    return sgn(b-a);
}

bool near(P a, P b) {
    return !sgn(abs(a-b));
}

R cross(P a, P b) { return imag(conj(a)*b); }
R dot(P a, P b) { return real(conj(a)*b); }


R ssqrt(R d) {
    d = max<R>(0, d);
    return sqrt(d);
}

R sacos(R d) {
    d = max<R>(-1, d);
    d = min<R>(1, d);
    return acos(d);
}

R deg2rad(R x) {
    return x/180*PI;
}

//?§???????[0, 2*PI)???
R radNorP(R x) {
    return fmod(fmod(x, 2*PI) + 2*PI, 2*PI);
}

/**
 * radian??§???x???[l, r]?????\??£????????????????????\??????
 * 0:OFF
 * 1:IN
 * 2:ON
 */
bool inR(R l, R r, R x) {
    l = radNorP(l);
    r = radNorP(r);
    x = radNorP(x);
    if (!sgn(l, x) || !sgn(r, x)) return 2;
    if (!sgn(l, r)) return 0;
    if (sgn(l, r) == 1) {
        if (sgn(l, x) == 1 && sgn(x, r) == 1) return 1;
    } else {
        if (sgn(x, r) == 1 || sgn(l, x) == 1) return 1;
    }
    return 0;
}
struct C {
    P p;
    R r;
    C () {}
    C (P p, R r) : p(p), r(r) {}
};
struct Sec {
    C c;
    R l, r;
    Sec() {}
    Sec(C c, R l, R r) : c(c), l(l), r(r) {}
};

bool crossSecP(const Sec &s, const P &p) {
    P pp = p - s.c.p;
    if (sgn(s.c.r, abs(pp)) == 1) return false;
    return inR(s.l, s.r, arg(pp)) > 0;
}

const int MN = 200;
int h, r, u, m, s;
R du, dm, ds;
P hp[MN];
P up[MN], mp[MN], sp[MN];
int res[MN];

void calc(R w, R a) {
    for (int i = 0; i < h; i++) {
        if (!crossSecP(Sec(C(P(0, 0), a), w-du, w+du), hp[i])) continue;
        bool f = true;
        for (int j = 0; j < u; j++) {
            if (crossSecP(Sec(C(up[j], a), w-du, w+du), hp[i])) f = false;
        }
        for (int j = 0; j < m; j++) {
            if (crossSecP(Sec(C(mp[j], a), w-dm, w+dm), hp[i])) f = false;
        }
        for (int j = 0; j < s; j++) {
            if (crossSecP(Sec(C(sp[j], a), w-ds, w+ds), hp[i])) f = false;
        }
        if (!f) continue;
        res[i]++;
    }
}

int main() {
    while (true) {
        cin >> h >> r;
        if (!h && !r) break;
        for (int i = 0; i < h; i++) {
            R x, y;
            cin >> x >> y;
            hp[i] = P(x, y);
        }
        cin >> u >> m >> s >> du >> dm >> ds;
        du /= 2; dm /= 2; ds /= 2;
        du = deg2rad(du);
        dm = deg2rad(dm);
        ds = deg2rad(ds);
        for (int i = 0; i < u; i++) {
            R x, y;
            cin >> x >> y;
            up[i] = P(x, y);
        }
        for (int i = 0; i < m; i++) {
            R x, y;
            cin >> x >> y;
            mp[i] = P(x, y);
        }
        for (int i = 0; i < s; i++) {
            R x, y;
            cin >> x >> y;
            sp[i] = P(x, y);
        }
        memset(res, 0, sizeof(res));
        for (int i = 0; i < r; i++) {
            R x, y;
            cin >> x >> y;
            calc(deg2rad(x), y);
        }
        int ma = 0;
        for (int i = 0; i < h; i++) {
            ma = max(ma, res[i]);
        }
        if (ma == 0) {
            cout << "NA" << endl;
            continue;
        }
        vector<int> buf;
        for (int i = 0; i < h; i++) {
            if (res[i] == ma) buf.push_back(i);
        }
        for (int i = 0; i < (int)buf.size()-1; i++) {
            cout << buf[i]+1 << " ";
        }
        cout << buf[buf.size()-1]+1 << endl;
    }
    return 0;
}

Measured memory_bytes: 1292