つーさのくーかん

#include <iostream>
#include <string>
#include <vector>
#include <stack>

using namespace std;

//#define SOLVE_A
//#define SOLVE_B
//#define SOLVE_C
//#define SOLVE_D

#ifdef SOLVE_A
// 10分くらい

// 素数系ではお約束、定番のエラトステネスをば。
const int MAX_PRIME = 1000000;
bool table[MAX_PRIME];
vector<int> primes;
void initprimes()
{
	memset(table, 0xFF, sizeof(table));
	table[0] = table[1] = false;
	for (int i = 2; i < MAX_PRIME; i++)
	{
		if (table[i])
		{
			primes.push_back(i);
			for (int j = i * 2; j < MAX_PRIME; j += i)
				table[j] = false;
		}
	}
}

int main()
{
	initprimes();
	while (true)
	{
		int n; cin >> n;
		if (n == 0)
			break;

		int count = 0;
		for (int i = n + 1; i <= 2 * n; i++)
			if (table[i])
				count++;

		cout << count << endl;
	}
	return 0;
}

#endif

#ifdef SOLVE_B
// 15分くらい
int main()
{
	while(true)
	{
		// 文字列を1行読む方法知ってますか？
		string line;
		getline(cin, line);
		
		if (line == ".")
			break;

		// 括弧の状態を保持するスタック
		stack<char> cacco;

		bool state = true;
		for (int i = 0; i < line.size(); i++)
		{
			switch(line[i])
			{
				case '(': cacco.push(')'); break;
				case '[': cacco.push(']'); break;
				case ')':
				case ']':
					if (!cacco.empty())
					{
						state &= cacco.top() == line[i];
						cacco.pop();
					}
					else
						state = false;
					break;
			}
		}
		cout << (state ? "yes" : "no") << endl;
	}
}

#endif


#ifdef SOLVE_C
// 40分くらい

// 配列を簡単にコピーしたいときは構造体に内包してしまうがよい。
struct Panel
{
	int c[10][10];
};

// pを塗り、塗ったマスの数を返す。前提: from == to だとバグる
int seedfill(Panel &p, int x, int y, int from, int to)
{
	if (p.c[x][y] != from)
		return 0;

	p.c[x][y] = to;
	return seedfill(p, x-1, y, from, to) + seedfill(p, x, y-1, from, to) +
		seedfill(p, x+1, y, from, to) + seedfill(p, x, y+1, from, to) + 1;
}

// 塗ったものを返す
Panel seedfill(Panel p, int to)
{
	if ( p.c[1][1] == to) return p;
	seedfill(p, 1, 1, p.c[1][1], to);
	return p;
}

// 塗ったマスの数を返す
int seedfillcount(Panel p)
{
	return seedfill(p, 1, 1, p.c[1][1], 0);
}

// 同じような処理をn重ループさせたいときは再帰関数が楽。
// 関数名dfsってなってるけど、別に検索してないなこれ。
int dfs(Panel p, int d, int last)
{
	if (d == 4)
	{
		seedfill(p, last);
		return seedfillcount(p);
	}

	int max = 0;
	for (int i = 1; i < 6; i++)
	{
		Panel pc = seedfill(p, i);
		int r = dfs(pc, d + 1, last);
		if (r > max)
			max = r;
	}
	return max;
}

int main()
{
	while(true)
	{
		int h, w, c;
		cin >> h >> w >> c;
		if (h == 0)
			break;

		// 読み込み
		Panel p0 = { {{0}} };
		for (int y = 0; y < h; y++)
			for (int x = 0; x < w; x++)
			{
				int k = 0;
				cin >> k;
				p0.c[x+1][y+1] = k;
			}

		// 再帰関数で書くか
		// cout << dfs(p0, 0, c) << endl;

		// 素直に4重ループで書くか
		#define REP(i,n) for (int i = 0; i < (n); i++)
		int max = 0;
		int i0 = p0.c[1][1];
		REP(i1, 6)
		{
			Panel p1 = seedfill(p0, i1 + 1);
			REP(i2, 6)
			{
				Panel p2 = seedfill(p1, i2 + 1);
				REP(i3, 6)
				{
					Panel p3 = seedfill(p2, i3 + 1);
					REP(i4, 6)
					{
						Panel p4 = seedfill(p3, i4 + 1);
						
						// 最後の1回は色が決まってる。
						Panel p5 = seedfill(p4, c);
						int count = seedfillcount(p5);
						if (count > max) max = count;
					}
				}
			}
		}
		cout << max << endl;
	}

	return 0;
}

#endif


#ifdef SOLVE_D
// 20分くらい

int visited[16777216];
// typedef bitset<24> Field; // とかもいいかも

struct Envan { int x, y, r, c; };
vector<Envan> envans;
vector<vector<int>> hit;


// 取り除けますか
inline bool isRemovable(int field, int i)
{
	// 円盤が存在するか
	bool ok = (field & 1 << i); // ←bitsetなら単にfield[i]と書ける

	// それよりも上に乗っている円盤がすべて存在しないか
	for (int j = 0; j < hit[i].size(); j++)
		ok = ok && ((field & 1 << hit[i][j]) == 0);

	return ok;
}


int dfs(int field)
{
	// 訪問済み
	if (visited[field] != -1)
		return visited[field];

	int max = 0;
	// 円盤二枚を選ぶ。
	for (int i = 0; i < envans.size(); i++)
	{
		if (!isRemovable(field, i)) continue;
		for (int j = i + 1; j < envans.size(); j++)
		{
			if (envans[i].c != envans[j].c) continue;
			if (!isRemovable(field, j)) continue;

			// 取り除いて次へ
			int r = dfs(field ^ (1 << i) | (1 << j)) + 2;
			if (r > max)
				max = r;
		}
	}

	return visited[field] = max;
}

int main()
{
	while(true)
	{
		int n;
		cin >> n;
		if (n == 0) break;

		// リセット
		envans.clear();
		hit.clear();
		memset(visited, 0xFF, sizeof(visited));

		// 読み込み
		for (int i = 0; i < n; i++)
		{
			int x, y, r, c;
			cin >> x >> y >> r >> c;
			Envan e = {x, y, r, c};
			envans.push_back(e);

			// ついでに重なり判定
			vector<int> hitting; // ←重なってるやつリスト
			for (int j = 0; j < i; j++)
			{
				int dx = envans[j].x - e.x;
				int dy = envans[j].y - e.y;
				int sr = envans[j].r + e.r;
				if (dx * dx + dy * dy < sr * sr)
					hitting.push_back(j);
			}
			hit.push_back(hitting);
		}
		cout << dfs((1<<envans.size())-1) << endl;
	}
	return 0;
}

#endif