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:
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;

const double EPS = 1.0e-10;

int bipartiteMaximumMatchings(const vector<vector<bool> >& graph)
{
    int ret = 0;
    int n = graph.size();
    int m = graph[0].size();
    vector<int> selectN(n, -1);
    vector<int> selectM(m, -1);

    for(int i=0; i<n; ++i){
        vector<bool> visitedN(n, false);
        vector<bool> visitedM(m, false);
        visitedN[i] = true;
        vector<int> path(min(n,m)*2, -1);

        path[0] = i;
        int index = 1;
        for(;;){
            while(++path[index] < m && (!graph[path[index-1]][path[index]] || selectN[path[index-1]]==path[index] || visitedM[path[index]]));
            if(path[index] < m){
                if(selectM[path[index]] == -1){
                    for(int j=0; j<index; j+=2){
                        selectN[path[j]] = path[j+1];
                        selectM[path[j+1]] = path[j];
                    }
                    ++ ret;
                    break;
                }
                if(!visitedN[selectM[path[index]]]){
                    path[index+1] = selectM[path[index]];
                    visitedM[path[index]] = true;
                    visitedN[path[index+1]] = true;
                    index += 2;
                }
            }
            else{
                path[index] = -1;
                index -= 2;
                if(index < 0)
                    break;
            }
        }

        if(ret == m)
            break;
    }

    return ret;
}

class Point
{
public:
    double y, x;
    Point(){
        y = x = 0.0;
    }
    Point(double y0, double x0){
        y = y0;
        x = x0;
    }
    Point operator+(const Point& p) const{
        return Point(y + p.y, x + p.x);
    }
    Point operator-(const Point& p) const{
        return Point(y - p.y, x - p.x);
    }
    Point operator*(double a) const{
        return Point(y * a, x * a);
    }
    Point operator/(double a) const{
        return Point(y / a, x / a);
    }
    double length() const{
        return sqrt(y * y + x * x);
    }
    double dist(const Point& p) const{
        return sqrt(pow(y - p.y, 2) + pow(x - p.x, 2));
    }
    double dot(const Point& p) const{
        return y * p.y + x * p.x; // |a|*|b|*cos慮
    }
    double cross(const Point& p) const{
        return x * p.y - y * p.x; // |a|*|b|*sin慮
    }
};

int circlesIntersection(const Point& p1, double r1, const Point& p2, double r2, vector<Point>& intersection)
{
    double y = p2.y - p1.y;
    double x = p2.x - p1.x;
    double a = (y*y + x*x + r1*r1 - r2*r2) / 2;
    double b = (y*y + x*x) * r1*r1 - a*a;

    if(y*y + x*x < EPS || b < -EPS){
        intersection.resize(0);
        return 0;
    }
    if(b < EPS){
        intersection.assign(1, Point(y, x) * (a / (y*y + x*x)) + p1);
        return 1;
    }

    intersection.assign(2, Point(x, -y) * sqrt(b));
    intersection[1] = intersection[1] * -1;
    for(int i=0; i<2; ++i)
        intersection[i] = (intersection[i] + Point(y, x) * a) / (y*y + x*x) + p1;
    return 2;
}

bool check(double r, const vector<Point>& p)
{
    int n = p.size();
    for(int i=0; i<n; ++i){
        for(int j=0; j<i; ++j){
            vector<Point> intersection;
            circlesIntersection(p[i], r, p[j], r, intersection);

            for(unsigned k=0; k<intersection.size(); ++k){
                bool ok = true;
                for(int l=0; l<n; ++l){
                    if(intersection[k].dist(p[l]) > r + EPS){
                        ok = false;
                        break;
                    }
                }
                if(ok)
                    return true;
            }
        }
    }

    return false;
}

int main()
{
    int n, m;
    cin >> n >> m;

    vector<double> r(n);
    for(int i=0; i<n; ++i)
        cin >> r[i];

    vector<vector<Point> > p(m);
    for(int i=0; i<m; ++i){
        int a;
        cin >> a;
        p[i].resize(a);
        for(int j=0; j<a; ++j)
            cin >> p[i][j].x >> p[i][j].y;
    }

    vector<vector<bool> > through(m, vector<bool>(n));
    for(int i=0; i<n; ++i){
        for(int j=0; j<m; ++j){
            through[j][i] = check(r[i], p[j]);
        }
    }

    vector<int> ret(m, -1);
    for(int i=0; i<m; ++i){
        for(int j=0; j<n; ++j){
            if(!through[i][j])
                continue;

            vector<bool> tmp(n, false);
            tmp[j] = true;
            swap(through[i], tmp);
            if(bipartiteMaximumMatchings(through) == m){
                ret[i] = j;
                break;
            }
            swap(through[i], tmp);
        }
        if(ret[i] == -1){
            cout << "NG" << endl;
            return 0;
        }
    }

    for(int i=0; i<m; ++i)
        cout << (ret[i] + 1) << endl;

    return 0;
}