#include<iostream>
#include<algorithm>
#include<set>
#include<vector>
#include<map>
#include<deque>
#include<queue>
#include<complex>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>

using namespace std;

#define REP(i,a,n) for(int i = a ; i < n ; i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-10)
typedef long long ll;
typedef complex<double> P;

namespace std {
	bool operator < (const P& a, const P& b) {
		return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
	}
}
double cross(const P& a, const P& b) {
	return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
	return real(conj(a)*b);
}

struct L : public vector<P>{
	L(){}
	L(const P &a , const P &b){
		push_back(a);
		push_back(b);
	}
};

int ccw(P a, P b, P c) {
	b -= a; c -= a;
	if (cross(b, c) > 0)	 return +1;			 // counter clockwise
	if (cross(b, c) < 0)	 return -1;			 // clockwise
	if (dot(b, c) < 0)		 return +2;			 // c--a--b on line
	if (norm(b) < norm(c)) return -2;			 // a--b--c on line
	return 0;
}

bool intersectLL(const L &l, const L &m) {
	return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
		abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;	 // same line
}
bool intersectLS(const L &l, const L &s) {
	return cross(l[1]-l[0], s[0]-l[0])*			 // s[0] is left of l
		cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
	return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
	return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
		ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
	return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}


P projection(const L &l, const P &p) {
	double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
	return l[0] + t * (l[0] - l[1]);
}
P reflection(const L &l, const P &p) {
	return p + 2.0 * (projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
	return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
	return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
	if (intersectLS(l, s)) return 0;
	return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
	const P r = projection(s, p);
	if (intersectSP(s, r)) return abs(r - p);
	return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
	if (intersectSS(s, t)) return 0;
	return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
				min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
	double A = cross(l[1] - l[0], m[1] - m[0]);
	double B = cross(l[1] - l[0], l[1] - m[0]);
	if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
	return m[0] + B / A * (m[1] - m[0]);
}

vector<vector<P> > lines;
int n;

bool sameline(const vector<P>& a, const vector<P>& b) {
	for (unsigned i = 0; i < a.size(); i++) {
//		cout << a[i] << b[i] << endl;
		if(abs(a[i] - b[i]) >= EPS) return false;
	}
	return true;
}

void solve() {
	const vector<P>& forword = lines[0];
	vector<P> backword(forword.rbegin(), forword.rend());
	P tmp = backword[0];
	for (unsigned i = 0; i < backword.size(); i++) {
		backword[i] -= tmp;
	}
	vector<int> indexes;
	for (int i = 1; i <= n; i++) {
		if (forword.size() != lines[i].size()) continue;
		for (int k = 0; k < 4; k++) {
			if (sameline(forword, lines[i])) {
				indexes.push_back(i);
			}
//			cout << i << "---" << endl;
			if (sameline(backword, lines[i])) {
				indexes.push_back(i);
			}
//			cout << "---" << endl;
			for (unsigned j = 0; j < lines[i].size(); j++) {
				lines[i][j] *= P(0, -1);
			}
		}
	}
	indexes.erase(unique(indexes.begin(), indexes.end()), indexes.end());
	for (unsigned i = 0; i < indexes.size(); i++) {
		cout << indexes[i] << endl;
	}
}

int main(){
	while (cin >> n, n) {
		lines.clear();
		for (int i = 0; i <= n; i++) {
			int m;
			cin >> m;
			lines.push_back(vector<P>(m));
			int x0, y0;
			cin >> x0 >> y0;
			lines[i][0] = P(0, 0);
			for (int j = 1; j < m; j++) {
				int x, y;
				cin >> x >> y;
				lines[i][j] = P(x - x0, y - y0);
			}
		}
		solve();
		cout << "+++++" << endl;
	}
}

Measured memory_bytes: 1256