import scala.annotation.tailrec
import scala.collection.mutable
import scala.io.StdIn._
object Main extends App {
  loop
  @tailrec
  def loop: Unit = {
    val Array(h, r) = readLine.trim.split(' ').map(_.toInt)
    if (h == 0) return
    val suspects = Array.tabulate(h){_ ⇒
      val Array(x, y) = readLine.trim.split(' ').map(_.toInt)
      Point(x, y)
    }
    val Array(u, m, s, du, dm, ds) = readLine.trim.split(' ').map(_.toInt)
    val ume = Array.tabulate(u){_ ⇒
      val Array(x, y) = readLine.trim.split(' ').map(_.toInt)
      Point(x, y)
    }
    val momo = Array.tabulate(m){_ ⇒
      val Array(x, y) = readLine.trim.split(' ').map(_.toInt)
      Point(x, y)
    }
    val sakura = Array.tabulate(s){_ ⇒
      val Array(x, y) = readLine.trim.split(' ').map(_.toInt)
      Point(x, y)
    }
    val umeAngle = Angle.byMeasure(du / 2.0)
    val momoAngle = Angle.byMeasure(dm / 2.0)
    val sakuraAngle = Angle.byMeasure(ds / 2.0)
    val trees = Array(ume → umeAngle, momo → momoAngle, sakura → sakuraAngle)
    val count = Array.tabulate(h){_ ⇒ 0}
    for (_ ← 0 until r){
      val Array(w, a) = readLine.trim.split(' ').map(_.toInt)
      val wind = Angle.byMeasure(w)
      var s = suspects.indices.filter(i ⇒ isReach(Point(0, 0), suspects(i), wind, umeAngle, a))
      s = s.filterNot(i ⇒ trees.exists{case (tree, angle) ⇒ tree.exists(t ⇒ isReach(t, suspects(i), wind, angle, a))})
      s.foreach(i ⇒ count(i) += 1)
    }
    println(
      if (count.forall(_ == 0)) "NA" else count.max match {case c ⇒ count.indices.filter(i ⇒ count(i) == c).map(_ + 1).mkString(" ")}
    )
    loop
  }

  def isReach(tree: Point, house: Point, wind: Angle, range: Angle, length: Int): Boolean = {
    (tree.distance(house) <= length) && (wind + range - Angle(tree.vectorTo(house))).sin >= 0 && (wind - range - Angle(tree.vectorTo(house))).sin <= 0
  }

  case class Point(x: Int, y: Int) {
    def distance(that: Point): Double = this - that match {case p ⇒ math.sqrt(p.x * p.x + p.y * p.y)}
    def -(that: Point): Point = Point(x - that.x, y - that.y)
    def vectorTo(that: Point): Vector = that - this match {case Point(dx, dy) ⇒ Vector(dx, dy)}
  }

  case class Vector(x: Int, y: Int) {
    def dot(that: Vector): Int = x * that.x + y * that.y
    def cross(that: Vector): Int = x * that.y - y * that.x
  }
  object Angle{
    def byMeasure(measure: Double): Angle = {
      val rad = measure / 180 * math.Pi
      new Angle(math.sin(rad), math.cos(rad))
    }
    def apply(vector: Vector): Angle = math.sqrt(vector.x * vector.x + vector.y * vector.y) match {case n ⇒ new Angle(vector.y / n, vector.x / n)}
  }
  class Angle private (val sin: Double, val cos: Double) {
    def +(that: Angle): Angle = new Angle(sin * that.cos + cos * that.sin, cos * that.cos - sin * that.sin)
    def -(that: Angle): Angle = new Angle(sin * that.cos - cos * that.sin, cos * that.cos + sin * that.sin)
  }
}
