Problem: G: Code Art Online

Code Art Online (CAO) is an online RPG that advances adventures by solving various problems by programming. Since CAO was the world's first game that realized a virtual reality space, it was sold out while it was very popular, and users who purchased the game should enjoy this world. However, players who dive into the game are told a terrifying decree by the gamemaster.

"Unless some of you players solve the last problem of the last dungeon, you can't get out of this virtual space. And in this world, WA and TLE / RE mean death in the real world. I want you to start the problem with your heart. "

You are one of the CAO players, and you are doing your best to capture the game in order to clear this game and return to the real world. One day, you face the following problems.

This time, a party was formed with n members to capture the new dungeon. You are one of the parties. In order to enter the dungeon that you are about to capture, you must pass through a hole that can be seen from the cliff. If you can pass through the hole safely, you can enter the dungeon, but if you can not enter the hole and touch other parts, death is waiting. Furthermore, if someone passes through one hole, that hole will close, so each person must enter a separate hole.

Holes and people are considered on a two-dimensional plane. The shape of the hole is a circle of various sizes, as shown in Fig. G-1. In the input, the length of the radius is given.

<image>
---
Figure G-1: Hole shape

As shown in Fig. G-2, the human shape is given as a polygonal cross section of the human (not necessarily convex). In the input, the vertices are given counterclockwise to represent the shape of the polygon. It can be assumed that any three points of a polygon do not line up on a straight line. Furthermore, it is assumed that polygonal line segments do not intersect each other except for the purpose of forming vertices. It may rotate freely to pass through the hole (however, rotation in the z-axis direction is prohibited). It is assumed that the vertices of a polygon representing a person can pass through the hole even if it is on the circumference of the hole.

<image>
---
Figure G-2: Human shape

You, who have the highest algorithm skills in the party, decided to solve the decision problem of whether everyone can pass through the hole safely. If you can pass it safely, indicate who should pass which hole.

* You will not die in this contest, but if you make a mistake, please solve it with the intention of dying.

Input

On the first line, the integer n (1 <= n <= 100), which represents the number of holes, and the integer m (1 <= m <= n), which represents the number of parties, are entered separated by spaces.

In the next line, n integers ri (1 <= ri <= 1000) representing the radius of the hole are entered, separated by spaces. These holes are counted as the 1st hole, the 2nd hole, ..., and the nth hole in the order of input.

Then, information on the shape of m people is input. For the information of one person, the number of vertices p (3 <= p <= 100) of the polygon is first input to the first line. In the following line p, the coordinates of the vertices of the polygon are given counterclockwise. Integers xi, yi (-1000 <= xi, yi <= 1000) representing one vertex are entered in each line, separated by spaces. People are counted as the 1st person, the 2nd person, ..., and the mth person in the order of input.

Output

Output the number of hole that the person with i (1 <= i <= m) should enter. On the i-line, output the number of the hole that the person i should pass through.

If there are multiple paths, output the smallest path in lexicographical order. When there are two sequences A = {a1, a2, ..., am} and B = {b1, b2, ..., bm}, if A is smaller than B in lexicographical order, ai is bi. For the first i that is different, we say when ai is smaller than bi.

If no way is found, output one line as "NG". Don't forget to print a newline at the end.

Sample Input 1


3 3
25 100 10
8
-10 0
-twenty two
0 10
twenty two
10 0
twenty two
0 -10
-twenty two
Four
30 0
50 0
50 40
30 40
3
30 -10
45 -70
60 -10


Sample Output 1


3
1
2


Sample Input 2


4 3
25 15 15 30
Five
0 0
10 0
20 10
0 20
-20 10
3
20 0
40 0
30 10
3
-50 0
-30 0
-40 10


Sample Output 2


1
2
3


Sample Input 3


twenty two
1 30
Four
0 0
10 0
10 10
0 10
3
5 5
20 20
5 20


Sample Output 3


NG






Example

Input

3 3
25 100 10
8
-10 0
-2 2
0 10
2 2
10 0
2 -2
0 -10
-2 -2
4
30 0
50 0
50 40
30 40
3
30 -10
45 -70
60 -10


Output

3
1
2

Solution (in CPP):

Solution:
//Name: Code Art Online
//Level: 3
//Category: 幾何,Geometry,最小包含円,マッチング,辞書順最小
//Note:

/*
 * まず、ある図形が穴を通れるかは、図形の最小包含円を求めて、その直径と穴の直径を比較すればよい。
 * 
 * これを元に図形と円の二部グラフができるので、辞書順最小マッチングを求める。
 * 左側のノード1を対応させる右側頂点をひとつ決めて、残りの頂点でマッチングができるなら採用、そうでなければ他の頂点を試す……という操作を繰り返せば良い。
 *
 * オーダーは O(MP log P + (NM)^2)。
 * ただし、辞書順最小マッチングの実際のループ数は(NM)^2回よりずっと少ないはずである。
 */
#include <iostream>
#include <vector>
#include <algorithm>
#include <complex>
#include <numeric>

using namespace std;

typedef complex<double> P;
const double EPS = 1e-9;

pair<P, double> enclosing_circle(const vector<P> &ps) {
    P c = accumulate(begin(ps), end(ps), P(0, 0)) / (double)ps.size();
    for(int i = 0; i < 1000; ++i) {
        P farthest;
        double maxd = 0;
        for(const P &p : ps) {
            double d = abs(c - p);
            if(d > maxd) {
                farthest = p;
                maxd = d;
            }
        }
        P vec = farthest - c;
        c += vec * pow(0.9, i+1);
    }
    double d = 0;
    for(const P &p : ps) {
        d = max(d, abs(p-c));
    }
    return make_pair(c, d);
}

bool bm_augment(const vector<vector<int> >& g, int u, vector<int>& match_to, vector<bool>& visited) // {{{
{
  if (u < 0) {
    return true;
  }

  for (vector<int>::const_iterator it(g[u].begin()); it != g[u].end(); ++it) {
    if (!visited[*it]) {
      visited[*it] = true;
      if (bm_augment(g, match_to[*it], match_to, visited)) {
        match_to[u] = *it;
        match_to[*it] = u;
        return true;
      }
    }
  }
  return false;
} // }}}

bool bipartite_matching(const vector<vector<int> >& g, int S, int L, const vector<bool> &used)  // {{{
{
  const int N = g.size();
  vector<int> match_to(N, -1);
  for (int u = S; u < L; u++) {
      vector<bool> visited = used;
      if(!bm_augment(g, u, match_to, visited)) return false;
  }
  return true;
} // }}}

bool solve() {
    int N, M;
    if(!(cin >> N >> M)) return false;

    vector<double> holes(N);
    for(int i = 0; i < N; ++i) {
        cin >> holes[i];
    }
    vector<double> persons(M, 0);
    for(int i = 0; i < M; ++i) {
        vector<P> vs;
        int Ps;
        cin >> Ps;
        for(int j = 0; j < Ps; ++j) {
            double x, y;
            cin >> x >> y;
            vs.emplace_back(x, y);
        }
        auto c = enclosing_circle(vs);
        persons[i] = c.second;
    }

    vector<vector<int>> g(M + N);
    for(int i = 0; i < M; ++i) {
        for(int j = 0; j < N; ++j) {
            if(persons[i] < holes[j]+EPS) {
                g[i].push_back(M+j);
            }
        }
    }
    vector<int> ans;
    vector<bool> used(M + N, false);
    if(!bipartite_matching(g, 0, M, used)) {
        cout << "NG" << endl;
        return true;
    }
    for(int i = 0; i < M; ++i) {
        for(int to : g[i]) {
            if(used[to]) continue;
            used[to] = true;
            if(bipartite_matching(g, i+1, M, used)) {
                ans.push_back(to+1-M);
                break;
            }
            used[to] = false;
        }
    }
    for(int a : ans) {
        cout << a << endl;
    }
    return true;
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(0);

    while(solve()) ;
    return 0;
}