Problem:
テトラ姫のパズル

パレス王国のテトラ姫は無類のパズル好きとして知られており，最近は自身が考案した「テトラパズル」に熱中している．
これは，正三角形のマスを敷き詰めたボードと，テトラブロックと呼ばれる 4 枚の正三角形のパネルからなる正四面体のブロックを使ったパズルである．
パズルの目的は，ボード上のすべてのテトラブロックを以下の条件をみたすように展開することである．

展開されたテトラブロックが，置かれていたマスおよび，それぞれに指定された異なる 2 つのマスを覆っている

どのマスも，2 つ以上のパネルで覆われていない

図F-1はテトラパズルの問題例および，その解答例である．
★のマスと●のマスにテトラブロックが置かれており，それぞれが☆のマスと○のマスを覆うように指定されている．
解答例において，横線が引かれたマスは★のマスに置かれていたテトラブロックを展開して覆ったマス，縦線のマスは●のマスに置かれたテトラブロックで覆ったマスである．

図 F-1: テトラパズルの問題例(左)および解答例(右)

図F-2は，上図の問題例における無効な解答例である．
左の例では★のマスの真上のマスが2つのパネルで覆われており，右の例ではそれぞれがテトラブロックを展開して得られる形状でないため，答えとしては認められない．

図 F-2: 無効な解答例

テトラ姫はパズルの面白さを多くの人に知ってもらうべく，来たる夏の祭典に向けてパズルの問題集を作った．
そして，王国で二番目のパズル好きとして姫から信頼を置かれているあなたは，問題集のチェック担当に任命された．

さて，チェック作業を進めていたあなたは困った事に気が付いた．
問題集には解が存在しないパズルが含まれているようなのだ．
なるべく姫の作ったパズルを尊重したいと考えたあなたは，解が存在しないパズルについて，どれか 1 個のテトラブロックをそのテトラブロックが覆うべきマスの情報ごと削除することで，パズルを解けるものに変えることにした．
姫から言い渡されたチェックの締切りまではあと3時間しかない．
問題集を見なおして，手早く修正を済ませてしまおう．

Input

入力は複数のデータセットから構成される．
各データセットの形式は次の通りである．

n
x1a y1a x1b y1b x1c y1c
x2a y2a x2b y2b x2c y2c
...
xna yna xnb ynb xnc ync

n (2 ≤ n ≤ 5,000) はボードに置かれたテトラブロックの数を表す整数である．
各テトラブロックには 1 から n の番号が割り当てられている．

続く n 行は，それぞれ 1 個のスペースで区切られた 6 個の整数からなる．
(xia, yia) は i 番目のテトラブロックが置かれているマスの座標を表し，(xib, yib) および，(xic, yic) は，それぞれ i 番目のテトラブロックを展開した時に覆うべきマスの座標を表す．
与えられる x 座標および y 座標の絶対値は 20,000 以下と仮定して良い．
また，与えられる座標は全て互いに異なると仮定して良い．
すなわち，同じマスに 2 個以上のテトラブロックが置かれる事や，テトラブロックが置かれているマスが覆うべきマスとして指定される事や，覆うべきマスが重複して指定される事はない．

各マスには図F-3のように座標が割り当てられている．

図 F-3: マスに割り当てられた座標

n=0 は入力の終わりを示す．これはデータセットには含めない．

Output

各データセットについて，テトラブロックを除くことなくパズルが解ける場合は Valid をそれぞれ 1 行に出力しなさい．
テトラブロックを 1 個だけ除くことでパズルが解けるようになる場合は Remove を 1 行に出力し，続けて除くことでパズルが解けるようになるテトラブロックの番号を小さいものから順にそれぞれ 1 行に出力しなさい．
2 個以上のテトラブロックを除かないとパズルが解けるようにならない場合は Invalid を1行に出力しなさい．

Sample Input

3
2 3 2 2 2 1
2 0 1 -1 2 -1
-2 -1 -1 -1 -2 0
6
-1 0 1 0 0 -1
-2 -1 -3 -2 -4 -2
2 -1 2 0 1 -1
4 -2 3 -2 3 -1
1 1 0 1 -1 1
-3 -1 -1 -1 -2 0
5
-1 2 0 2 1 2
-3 1 -2 1 -2 2
-2 0 -2 -1 -3 0
1 -1 0 -1 -1 -1
1 0 2 0 2 -1
4
-2 0 -2 -1 -3 -1
-1 -1 0 -1 1 -1
2 -1 2 0 3 -1
-1 0 0 0 1 0
5
-2 1 3 -1 2 1
-5 2 -5 3 -4 2
-2 -1 0 -1 -3 -1
4 2 5 2 5 3
1 -1 2 -1 -1 -1
0

以下の図はそれぞれサンプルの配置を示している．

図 F-4: 1番目のサンプル

図 F-5: 2番目のサンプル

図 F-6: 3番目のサンプル

図 F-7: 4番目のサンプル

図 F-8: 5番目のサンプル

Output for Sample Input

Remove
1
Remove
2
6
Valid
Remove
1
2
3
4
Invalid

Solution in C++14 (judge verdict: Wrong Answer)

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

#define for_(i,a,b) for(int i=(a);i<(b);++i)
#define allof(a) (a).begin(),(a).end()
typedef pair< int, int > pii;

class BipartiteMatching {
private:
	int V;
	vector< vector< int > > adj;
	vector< int > match;
	vector< bool > used;
	vector< bool > visible;
	
	bool dfs(int v) {
		used[v] = 1;
		
		for (int u : adj[v]) {
			if (!visible[u]) continue;
			
			int w = match[u];
			if (w < 0 || (!used[w] && dfs(w))) {
				match[v] = u;
				match[u] = v;
				return 1;
			}
		}
		
		return 0;
	}
	
public:
	BipartiteMatching(int n) : V(n), adj(n, vector< int >()), match(n, -1), used(n, 0), visible(n, false) {}
	
	void addEdge(int u, int v) {
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	
	bool startDFS(int v) {
		if (!visible[v] || match[v] >= 0) return false;
		fill(allof(used), 0);
		return dfs(v);
	}
	
	void setVisible(int v) { visible[v] = true; }
	void setUnvisible(int v) { visible[v] = false; }
	void setUnmatch(int v) { match[v] = -1; }
	
	int getMatch(int v) { return match[v]; }
};



int n, x[5000][3], y[5000][3], par[5000][3];
set< pii > candidates[5000];
set< int > cand_id[5000];

const int dx[2][3] = {{1,0,-1}, {1,0,-1}};
const int dy[2][3] = {{0,-1,0}, {0,1,0}};
const int add[3][2][3] = {
	{{0,0,0}, {0,0,0}},
	{{1,0,1}, {0,1,0}},
	{{0,1,0}, {1,0,1}}
};

int getPar(pii p) { return (abs(p.first) + abs(p.second)) % 2; }

bool validPieces(set< pii >& pset) {
	int deg_sum = 0, max_deg = 0;
	for (pii p : pset) {
		int deg = 0;
		for_(d,0,3) {
			pii pi(p.first + dx[getPar(p)][d], p.second + dy[getPar(p)][d]);
			deg += pset.count(pi);
		}
		max_deg = max(max_deg, deg);
		deg_sum += deg;
	}
	
	if (deg_sum != 6) return false;
	if (max_deg == 3) return true;
	
	for (pii p : pset) for_(a,0,3) {
		bool flag = true;
		pii cur = p;
		int par = getPar(p);
		for_(d,0,3) {
			pii np(cur.first + dx[getPar(cur)][add[a][par][d]], cur.second + dy[getPar(cur)][add[a][par][d]]);
			flag &= (pset.count(np) == 1);
			cur = np;
		}
		if (flag) return true;
	}
	return false;
}

void makeCandidates() {
	for_(i,0,n) {
		candidates[i].clear();
		set< pii > pset;
		for_(j,0,3) pset.insert(pii(x[i][j], y[i][j]));
		for_(j,0,3) for_(d,0,3) {
			set< pii > pset_j = pset;
			pii np(x[i][j] + dx[par[i][j]][d], y[i][j] + dy[par[i][j]][d]);
			pset_j.insert(np);
			if (pset_j.size() == 4 && validPieces(pset_j)) candidates[i].insert(np);
		}
	}
}

void solve() {
	makeCandidates();
	
	map< pii, int > pii_to_id;
	int new_id = 0;
	for_(i,0,n) {
		for (pii p : candidates[i]) {
			if (pii_to_id.count(p)) continue;
			pii_to_id[p] = new_id++;
			cand_id[i].insert(pii_to_id[p]);
		}
	}
	
	int m = pii_to_id.size();
	BipartiteMatching bm(n + m);
	for_(i,0,n) for (pii p : candidates[i]) bm.addEdge(i, n + pii_to_id[p]);
		
	for_(i,0,n+m) bm.setVisible(i);
	for_(i,0,n) for_(j,0,3) {
		pii p(x[i][j], y[i][j]);
		if (pii_to_id.count(p)) bm.setUnvisible(n + pii_to_id[p]);
	}
	
	vector< int > miss;
	for_(v,0,n) bm.startDFS(v);
	for_(v,0,n) if (bm.getMatch(v) < 0) miss.push_back(v);
	
	if (miss.size() == 0) puts("Valid");
	else if (miss.size() > 4) puts("Invalid");
	else {
		vector< int > ans;		
		for_(u,0,n) {
			for_(j,0,3) {
				pii p(x[u][j], y[u][j]);
				if (pii_to_id.count(p)) bm.setVisible(n + pii_to_id[p]);
			}
			
			for_(v,0,n) {
				int id = bm.getMatch(v);
				if (cand_id[u].count(id)) {
					bm.setUnmatch(v);
					bm.setUnmatch(id);
				}
			}
			
			for_(v,0,n) if (v != u) bm.startDFS(v);
			bool no_miss = true;
			for_(v,0,n) if (v != u) no_miss &= (bm.getMatch(v) >= 0);
			if (no_miss) ans.push_back(u);
			
			for_(j,0,3) {
				pii p(x[u][j], y[u][j]);
				if (pii_to_id.count(p)) bm.setUnvisible(n + pii_to_id[p]);
			}
		}
		
		if (ans.size() == 0) puts("Invalid");
		else {
			puts("Remove");
			for (int v : ans) printf("%d\n", v+1);
		}
	}
}

int main() {
	while (1) {
		cin >> n;
		if (n == 0) break;
		for_(i,0,n) for_(j,0,3) {
			cin >> x[i][j] >> y[i][j];
			par[i][j] = (abs(x[i][j]) + abs(y[i][j])) % 2;
		}
		solve();
	}
}