#include <bits/stdc++.h>
using namespace std;

namespace geometry {
	// ???????????§??????
	
	typedef complex<double> Point;
	
	struct Segment {
		Point p1, p2;
		Segment(const Point &p1 = Point(), const Point &p2 = Point()): p1(p1), p2(p2){}
	};
	
	struct Circle {
		Point p;
		double r;
		Circle(const Point& p = Point(), double r = 0.0): p(p), r(r){}
	};
	
	typedef Point Vector;
	typedef Segment Line;
	typedef vector<Point> Polygon;
	
	
	// ??\??????
	
	inline istream & operator >> (istream &is, Point &p){
		double x, y;
		is >> x >> y;
		p.real(x), p.imag(y);
		return is;
	}
	
	inline istream & operator >> (istream &is, Segment &s){
		return is >> s.p1 >> s.p2;
	}
	
	inline istream & operator >> (istream &is, Circle &c){
		return is >> c.p >> c.r;
	}
	
	inline ostream & operator << (ostream &os, Segment &s){
		return os << "{" << s.p1 << ", " << s.p2 << "}";
	}
	
	inline ostream & operator << (ostream &os, Circle &c){
		return os << "{" << c.p << ", " << c.r << "}";
	}
	
	inline ostream & operator << (ostream &os, Polygon &g){
		os << "{";
		bool f = false;
		for (auto &p : g){
			if (f) os << ", ";
			os << p;
			f = true;
		}
		return os << "}";
	}
	
	
	// ?????°, ??????
	
	const double PI = acos(-1);
	const double EPS = 1e-8;
	const double INF = 1e16;
	const int COUNTER_CLOCKWISE = 1;
	const int CLOCKWISE 		= -1;
	const int ONLINE_BACK		= 2;
	const int ONLINE_FRONT		= -2;
	const int ON_SEGMENT		= 0;
	const int OUT				= 0;
	const int ON				= 1;
	const int IN				= 2;
	
	inline double square(double a){return a * a;}
	inline bool equal(double a, double b){return abs(a - b) < EPS;}
	inline bool equalVector(const Vector &a, const Vector &b){return equal(a.real(), b.real()) && equal(a.imag(), b.imag());}
	inline double norm(const Point &a){return square(a.real()) + square(a.imag());}
	inline double dot(const Point &a, const Point &b){return (conj(a) * b).real();}
	inline double cross(const Point &a, const Point &b){return (conj(a) * b).imag();}
	
	
	// ????????¢??° (x ??§?¨?, y ??§?¨?, ????§?)
	// ????§?????????????????????? Point rp ?????£??\????????????
	
	bool cmpx(const Point &a, const Point &b){
		if (!equal(a.real(), b.real())) return a.real() < b.real();
		return b.imag() < b.imag();
	}
	
	bool cmpy(const Point &a, const Point &b){
		if (!equal(a.imag(), b.imag())) return a.imag() < b.imag();
		return a.real() < b.real();
	}
	
	Point rp;
	bool cmparg(const Point &a, const Point &b){
		double rada = arg(a - rp); if (rada < 0.0) rada += 2 * PI;
		double radb = arg(b - rp); if (radb < 0.0) radb += 2 * PI;
		if (!equal(rada, radb)) return rada < radb;
		return norm(a) < norm(b);
	}
	
	
	// ??´???, ??????
	
	bool orthgonal(const Vector &a, const Vector &b){
		return equal(dot(a, b), 0.0);
	}
	
	bool parallel(const Vector &a, const Vector &b){
		return equal(cross(a, b), 0.0);
	}
	
	
	// ????°?, ?°???±
	
	Point project(const Segment &s, const Point &p){
		Vector base = s.p2 - s.p1;
		double r = dot(p - s.p1, base) / norm(base);
		return s.p1 + base * r;
	}
	
	Point reflect(const Segment &s, const Point &p){
		return p + (project(s, p) - p) * 2.0;
	}
	
	
	// ??????????????????
	
	int ccw(const Point &p0, const Point &p1, const Point &p2){
		Vector a = p1 - p0;
		Vector b = p2 - p0;
		if (cross(a, b) > EPS) return COUNTER_CLOCKWISE;
		if (cross(a, b) < -EPS) return CLOCKWISE;
		if (dot(a, b) < -EPS) return ONLINE_BACK;
		if (norm(a) > norm(b)) return ONLINE_FRONT;
		return ON_SEGMENT;
	}
	
	
	// ?????¢
	
	double distanceLP(const Line &l, const Point &p){
		return abs((l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
	}
	
	double distanceSP(const Segment &s, const Point &p){
		if (dot(s.p2 - s.p1, p - s.p1) < 0.0) return abs(p - s.p1);
		if (dot(s.p1 - s.p2, p - s.p2) < 0.0) return abs(p - s.p2);
		return distanceLP(s, p);
	}
	
	bool intersect(const Segment &s1, const Segment &s2);
	double distance(const Segment &s1, const Segment &s2){
		if (intersect(s1, s2)) return 0.0;
		return min(
			min(distanceSP(s1, s2.p1), distance(s1, s2.p2)),
			min(distanceSP(s2, s1.p1), distance(s2, s1.p2))
		);
	}
	
	
	// ????????????
	
	bool intersect(const Segment &s1, const Segment &s2){
		return ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0 &&
			ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0;
	}
	
	int intersect(const Circle &c, const Segment &s){
		// ???????????° (0 ~ 2) ?????????
		double dist = distanceSP(s, c.p) - c.r;
		if (dist < -EPS) return 2;
		if (equal(dist, 0.0)) return 1;
		return 0;
	}
	
	int intersect(const Circle &c1, const Circle &c2){
		// ???????????° (0 ~ 2) ?????????
		double dist = abs(c1.p - c2.p) - (c1.r + c2.r);
		if (dist < -EPS) return 2;
		if (equal(dist, 0.0)) return 1;
		return 0;
	}
	
	
	// ??????
	
	Point crossPoint(const Segment &s1, const Segment &s2){
		Vector base = s2.p2 - s2.p1;
		double d1 = abs(cross(base, s1.p1 - s2.p1));
		double d2 = abs(cross(base, s1.p2 - s2.p1));
		
		// !! ????????´?????¶????????????????????\????????¨ 0 ?????? !!
		assert(!equal(d1 + d2, 0.0));
		
		double t = d1 / (d1 + d2);
		return s1.p1 + (s1.p2 - s1.p1) * t;
	}
	
	vector<Point> crossPoints(const Circle &c, const Line &l){
		vector<Point> res;
		if (!intersect(c, l)) return res;
		
		Vector pr = project(l, c.p);
		Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
		double base = sqrt(c.r * c.r - norm(pr - c.p));
		res.push_back(pr + e * base);
		res.push_back(pr - e * base);
		if (equalVector(res[0], res[1])) res.pop_back();
		return res;
	}
	
	vector<Point> crossPoints(const Circle &c1, const Circle &c2){
		vector<Point> res;
		if (!intersect(c1, c2)) return res;
		
		double d = abs(c1.p - c2.p);
		double a = acos(square(c1.r) + square(d) - square(c2.r) / (2 * c2.r * d));
		double t = arg(c2.p - c1.p);
		res.push_back(c1.p + polar(c1.r, t + a));
		res.push_back(c1.p + polar(c1.r, t - a));
		if (equalVector(res[0], res[1])) res.pop_back();
	}
	
	
	// ??????
	
	int contains(const Polygon &g, const Point &p){
		int n = g.size();
		bool res = false;
		for (int i = 0; i < n; i++){
			Point a = g[i] - p;
			Point b = g[(i + 1) % n] - p;
			if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return ON;
			if (a.imag() > b.imag()) swap(a, b);
			if (a.imag() < EPS && EPS < b.imag() && cross(a, b) > EPS) res = !res;
		}
		return res ? IN : OUT;
	}
	
	
	// ??????
	
	Polygon convexHull(vector<Point> s){
		Polygon u, l;
		if (s.size() < 3) return s;
		sort(s.begin(), s.end());
		u.push_back(s[0]);
		u.push_back(s[1]);
		l.push_back(s[s.size() - 1]);
		l.push_back(s[s.size() - 2]);
		
		for (int i = 2; i < s.size(); i++){
			int n = u.size();
			while (n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE){
				u.pop_back();
				n--;
			}
			u.push_back(s[i]);
		}
		
		for (int i = s.size() - 3; i >= 0; i--){
			int n = l.size();
			while (n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE){
				l.pop_back();
				n--;
			}
			l.push_back(s[i]);
		}
		
		reverse(l.begin(), l.end());
		for (int i = u.size() - 2; i >= 1; i--){
			l.push_back(u[i]);
		}
		
		return l;
	}
}
namespace std {
	bool operator < (const geometry::Point &a, const geometry::Point &b){
		return geometry::cmpx(a, b);
	}
}



using namespace geometry;
int n;
Point p[40];
vector<int> np[40];
vector<int> res[41];

bool cmp(int a, int b){
	return cmparg(p[a], p[b]);
}

double area(Point &p, Point &a, Point &b){
	return cross(a - p, b - p) / 2;
}

void solve()
{
	// [?§????][n ?§???¢][2??????][1??????]
	static double dp[40][41][40][40];
	fill_n(***dp, 40 * 41 * 40 * 40, INF);
	
	for (int i = 0; i < n; i++){
		for (int j = 0; j < np[i].size(); j++){
			for (int k = j + 1; k < np[i].size(); k++){
				Point &p1 = p[np[i][j]];
				Point &p2 = p[np[i][k]];
				if (area(p[i], p1, p2) < 0.0) continue;
				if (p1.imag() < p[i].imag()) continue;
				if (p2.imag() <= p[i].imag()) continue;
				dp[i][3][j][k] = area(p[i], p1, p2);
			}
		}
	}
	
	for (int i = 0; i < n; i++){
		for (int j = 3; j < n; j++){
			for (int k = 0; k < np[i].size(); k++){
				for (int l = k + 1; l < np[i].size(); l++){
					for (int m = l + 1; m < np[i].size(); m++){
						Point &p0 = p[np[i][k]];
						Point &p1 = p[np[i][l]];
						Point &p2 = p[np[i][m]];
						if (p2.imag() <= p[i].imag()) continue;
						if (area(p0, p1, p2) < 0.0) continue;
						
						dp[i][j + 1][l][m] = min(
							dp[i][j + 1][l][m],
							dp[i][j][k][l] + area(p[i], p1, p2)
						);
					}
				}
			}
		}
	}
	
	for (int v = 3; v <= n; v++){
		int st = 0, t = 0, s = 0;
		for (int i = 0; i < n; i++){
			for (int j = 0; j < n; j++){
				for (int k = 0; k < n; k++){
					if (dp[st][v][s][t] > dp[i][v][j][k]){
						st = i;
						s = j;
						t = k;
					}
				}
			}
		}
		res[v].push_back(np[st][t] + 1);
		res[v].push_back(np[st][s] + 1);
		for (int i = v; i > 3; i--){
			bool f = false;
			for (int j = 0; j < n; j++){
				double cura = dp[st][i][s][t];
				double prea = dp[st][i - 1][j][s];
				double da = area(p[st], p[np[st][s]], p[np[st][t]]);
				if (cura == INF || prea == INF) continue;
				if (area(p[np[st][j]], p[np[st][s]], p[np[st][t]]) < 0.0) continue;
				if (equal(cura - prea, da)){
					t = s;
					s = j;
					f = true;
					break;
				}
			}
			if (!f) break;
			res[v].push_back(np[st][s] + 1);
		}
		res[v].push_back(st + 1);
		reverse(res[v].begin(), res[v].end());
	}
}

void output(int v)
{
	if (res[v].size() != v) cout << "NA" << endl;
	else {
		for (int i = 0; i < v; i++){
			if (i) cout << " ";
			cout << res[v][i];
		}
		cout << endl;
	}
}

int main()
{
	cin >> n;
	for (int i = 0; i < n; i++){
		cin >> p[i];
	}
	
	for (int i = 0; i < n; i++){
		for (int j = 0; j < n; j++){
			if (i != j) np[i].push_back(j);
		}
		rp = p[i];
		sort(np[i].begin(), np[i].end(), cmp);
	}
	
	solve();
	
	int Q;
	cin >> Q;
	while (Q--){
		int v;
		cin >> v;
		output(v);
	}
}

Measured memory_bytes: 21856