Let's write a program related to an unsolved math problem called "Happy End Problem". Create a program to find the smallest convex polygon formed by connecting exactly k points from the N points given on the plane. However, after being given the coordinates of N points, the question is given the number k of the angles of the convex polygon.

(Supplement: About the happy ending problem)
Place N points on the plane so that none of the three points are on the same straight line. At that time, no matter how you place the points, it is expected that if you select k points well, you will definitely be able to create a convex polygon with k corners. So far, it has been proved by 2006 that N = 3 for triangles, N = 5 for quadrilaterals, N = 9 for pentagons, and N = 17 for hexagons. There is also a prediction that N = 1 + 2k-2 for all k-sides above the triangle, but this has not yet been proven. This is a difficult problem that has been researched for 100 years.
This question has a nice name, "Happy End Problem". A friend of mathematicians named it after a man and a woman became friends while studying this issue and finally got married. It's romantic.



input

The input consists of one dataset. Input data is given in the following format.


N
x1 y1
::
xN yN
Q
k1
::
kQ


The number of points N (3 ≤ N ≤ 40) on the plane is given in the first line. The coordinates of each point are given in the following N lines. Each point is numbered from 1 to N in the order in which they are entered. xi and yi (-10000 ≤ xi, yi ≤ 10000) are integers representing the x and y coordinates of the i-th point, respectively. The positive direction of the x-axis shall be to the right, and the positive direction of the y-axis shall be upward.

The number of questions Q (1 ≤ Q ≤ N) is given in the following line. A question is given to the following Q line. ki (3 ≤ ki ≤ N) represents the number of corners of the convex polygon, which is the i-th question.

The input shall satisfy the following conditions.

* The coordinates of the input points are all different.
* None of the three points are on the same straight line.
* For each question, there is only one convex polygon with the smallest area, and the difference in area from the second smallest convex polygon is 0.0001 or more.

output

For each question, output all vertices of the convex polygon with the smallest area on one line. The number of vertices is output counterclockwise in order from the leftmost vertex among the bottom vertices of the convex polygon. Separate the vertex numbers with a single space. Do not print whitespace at the end of the line. However, if a convex polygon cannot be created, NA is output.

Example

Input

5
0 0
3 0
5 2
1 4
0 3
3
3
4
5


Output

1 4 5
1 2 4 5
1 2 3 4 5
def cross(z1, z2):
    return z1.real * z2.imag - z1.imag * z2.real

def ccw(p1, p2, p3):
    return cross(p2 - p1, p3 - p1) > 0

def triangle_area(p1, p2, p3):
    # returns signed trangle area
    return cross(p2 - p1, p3 - p1) / 2

from sys import stdin
file_input = stdin

N = int(file_input.readline())
P = []
M = {}

for i in range(1, N + 1):
    x, y = map(int, file_input.readline().split())
    z = x + y * 1j
    P.append(z)
    M[z] = i # point to id

Q = int(file_input.readline())
query = [int(file_input.readline()) for i in range(Q)]
ql = max(query) - 2

P.sort(key=lambda x: (x.imag, x.real))

max_area = 20000 * 20000
CP_area = [max_area for i in range(ql)]
CP_points = [None for i in range(ql)]

from cmath import phase
from itertools import combinations

for i, bp in enumerate(P[:-2], start=1):
    tP = P[i:]
    tP.sort(key=lambda x: phase(x - bp))
    pn = N - i
    
    tM = dict(zip(range(pn), tP)) # id to point
    
    # making triangles
    t_rec = [[None for k in range(pn)] for j in range(pn)]
    for j, k in combinations(range(pn), 2):
        pj, pk = tM[j], tM[k]
        ta = triangle_area(bp, pj, pk)
        t_rec[j][k] = [ta, [bp, pj, pk]]
        if ta < CP_area[0]:
            CP_area[0] = ta
            CP_points[0] = [bp, pj, pk]
    
    # making convex polygons
    prev = t_rec.copy()
    cur = [[None for k in range(pn)] for j in range(pn)]
    for i in range(1, ql):
        for j, k, s in combinations(range(pn), 3):
            pre_cp = prev[j][k]
            if pre_cp:
                pj, pk, ps = tM[j], tM[k], tM[s]
                if ccw(pj, pk, ps):
                    ta = pre_cp[0] + t_rec[k][s][0]
                    if not cur[k][s] or cur[k][s][0] > ta:
                        cur[k][s] = [ta, pre_cp[1] + [tM[s]]]
                        if ta < CP_area[i]:
                            CP_area[i] = ta
                            CP_points[i] = cur[k][s][1]
        
        prev = cur.copy()
        cur = [[None for k in range(pn)] for j in range(pn)]

# output
for q in query:
    if CP_points[q-3]:
        print(' '.join(map(lambda x: str(M[x]), CP_points[q-3])))
    else:
        print("NA")
