Problem:
宝くじ
ある国の王様は素数とギャンブルが大好きです。この国の通貨の単位はプライムといいます。2007 年 11 月 1 日現在のプライムのクロス円レートは 9973 とちょうど素数になっていたので、王様は大喜びです。この国では 1/101 プライムを1サブプライムとする補助貨幣が使われています。
この国の政府は、国家財政の安定、国民の娯楽、王様の趣味を同時に満足させることを目的に宝くじ振興公社を設立し、宝くじ事業を始めることにしました。素数が大好きな王様は、素数が話題になればそれだけで満足して、賞金をあげたくなります。そこで振興公社は次のような宝くじを考えました。
くじには 0 から
MP
までの一連の番号がつけられている。
MP
はこの国で知られている最大の素数で、毎月一日に官報で告示される。同時に、
MP
以下のすべての素数も発表される。それ以上大きな素数が発見されても、その月の間は、宝くじ振興公社を含む全ての公的な機関では、一日に発表された
MP
を最大の素数として扱う。2007 年 11 月 1 日 には
MP
= 999983 (1000000 以下の最大の素数) が発表された。
宝くじの販売価格は 1 サブプライム。
宝くじの抽選では、当たりくじの番号
p
と賞金算出のための数
m
の組(
p
,
m
) が何組か選ばれる。
p
,
m
はそれぞれ0 以上
MP
以下の整数。
この国で知られている素数の中で
p
-
m
以上
p
+
m
以下のものが
X
個あるとすると、抽選結果(
p
,
m
) の賞金は、
X
プライムとなる。
抽選結果 (
p
,
m
) の賞金
X
プライムは番号
p
の宝くじを持っている当選者に支払われるが、
X
= 0 の場合もあり、この場合には当選者には賞金は支払われない。
賞金のうち 1 プライムは宝くじの売り上げから支出され、
X
- 1 プライムは王様の内廷費から支出される（王様が払ってくれる）。
X
= 0 ならば宝くじの売り上げから 1 プライムが内廷費に繰り入れられる。（王様に対し支払われる）
ひとつの番号
p
が複数の当たりくじになることもある。この場合にはそれぞれの抽選結果(
p
,
m
) から算出される賞金の合計が当選者に支払われる。
このくじでは当たりくじを買った人は抽選結果から関係する素数を探し、その個数を数えるので、国民の話題に素数がよく出てきて王様はとてもご満悦です。宝くじ振興公社としては当たりくじ1本当たり公社負担が 1 プライム、販売価格が 1 サブプライムだから、当たりくじの本数
n
を、販売した宝くじ 101 本あたり 1 本以下となるようにすれば (すなわち、
n
≤ (販売した本数)/101 とすれば) 赤字にはなりません。
問題は内廷費からの支出額です。あなたの仕事は、抽選結果を入力として、2007 年 11 月における宝くじ振興公社が王様に請求する賞金の額を出力するプログラムを作成することです。ただし、請求する賞金の額が負になることはないものとします。
注意
この国における素数の定義も日本の学校教育で学習する内容と同じです。即ち、素数とは 1 と自分自身以外の約数を持たない自然数をいいます（なお、1 は素数ではありません）。
我々は 1000003 が素数であることを知っていますが、この国では 2007 年 11 月段階では知られていません。そのため、999963 以上 1000003 以下の範囲にあるこの国で知られている素数は 999983 と 999979 の 2 個しかありません。
Input
複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。
n
p
1
m
1
p
2
m
2
:
p
n
m
n
１行目に抽選結果の数
n
(1 ≤
n
≤ 1000000)、続く
n
行に
i
番目の抽選結果の情報
p
i
,
m
i
が空白区切りで与えられます。
データセットの数は 20 を超えません。
Output
データセットごとに王様への請求額をプライム単位（整数）で１行に出力します。
Sample Input
4
5 0
9 1
3 10
11 3
1
999983 20
0
Output for the Sample Input
5
1

Submitted solutions:

code_snippet: #include <bits/stdc++.h>

using namespace std;

const int MaxLimit = 1000001;
bool PrimeNumber[MaxLimit] = { false,false, true,true,false };
int Total[MaxLimit] = { 0,0,1,2,2 };

void findPrimeNumber() {
	int limit;
	bool flag;

	for (int i = 5; i < MaxLimit; i++) {
		if (i % 2 == 0) {
			PrimeNumber[i] = false;
			Total[i] = Total[i - 1];
			continue;
		}

		limit = sqrt(i) + 1;
		for (int j = 2; j < limit; j++) {
			if (i%j == 0) {
				flag = false;
				PrimeNumber[i] = false;
				Total[i] = Total[i - 1];
				break;
			}
			flag = true;
		}
		if (flag) {
			PrimeNumber[i] = true;
			Total[i] = Total[i - 1] + 1;
		}
	}
}

int main() {
	int n, p, m, minLimt, maxLimt, cnt, sum;

	findPrimeNumber();
	while (cin >> n, n) {
		sum = 0;
		for (int i = 0; i < n; i++) {
			cnt = 0;
			cin >> p >> m;
			minLimt = max(1, p - m);
			maxLimt = min(MaxLimit-1, p + m);
			cnt = Total[maxLimt] - Total[minLimt-1];
			//cout << p << ":" << m << " = " << cnt << endl;
			if (cnt == 0) {
				--sum;
			}
			else {
				sum += cnt - 1;
			}
		}
		cout << sum << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 150
memory_kb: 7956
final_rank: 14

code_snippet: #include <bits/stdc++.h>

using namespace std;

const int MaxLimit = 1000001;
bool PrimeNumber[MaxLimit] = { false,false, true,true,false };
int Total[MaxLimit] = { 0,0,1,2,2 };

void findPrimeNumber() {
	int limit;
	bool flag;

	for (int i = 5; i < MaxLimit; i++) {
		if (i % 2 == 0) {
			PrimeNumber[i] = false;
			Total[i] = Total[i - 1];
			continue;
		}

		limit = sqrt(i) + 1;
		for (int j = 2; j < limit; j++) {
			if (i%j == 0) {
				flag = false;
				PrimeNumber[i] = false;
				Total[i] = Total[i - 1];
				break;
			}
			flag = true;
		}
		if (flag) {
			PrimeNumber[i] = true;
			Total[i] = Total[i - 1] + 1;
		}
	}
}

int main() {
	int n, p, m, minLimt, maxLimt, cnt, sumToking, sumToPerson;

	findPrimeNumber();
	while (cin >> n, n) {
		sumToking = sumToPerson = 0;
		for (int i = 0; i < n; i++) {
			cnt = 0;
			cin >> p >> m;
			minLimt = max(1, p - m);
			maxLimt = min(MaxLimit-1, p + m);
			cnt = Total[maxLimt] - Total[minLimt-1];
			/*if (PrimeNumber[minLimt] || PrimeNumber[maxLimt]) {
				++cnt;
			}*/
			//cout << p << ":" << m << " = " << cnt << endl;
			if (cnt == 0) {
				++sumToking;
			}
			else {
				sumToPerson += cnt - 1;
			}
		}
		cout << sumToPerson - sumToking << endl;
	}

	return 0;
}
accuracy: 1
time_ms: 150
memory_kb: 7864
final_rank: 13

code_snippet: #include "bits/stdc++.h"

#define REP(i,num) for(int i=0;i<(num);++i)
#define ALL(c) c.begin(),c.end()
#define LOOP(i) while(i--)
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}

using namespace std;
using ll = long long;

constexpr ll atcoder_mod = 1e9+7;

template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}

void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}

vector<ll> enum_prime(ll N){
	deque<bool> is_prime(N+1,true);
	vector<ll> P;
	for(ll i=2;i<=N;i++){
		if(is_prime[i]){
			for(ll j=i*i;j<=N;j+=i){
				is_prime[j] = false;
			}
			P.emplace_back(i);
		}
	}
	return P;
}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);

	auto P=enum_prime(1000000);
	vector<ll> H(2000000,0),S(2000001,0);
	for(auto& x:P) H[x]=1;
	for(int i=0;i<2000000;i++){
		S[i+1]=S[i]+H[i];
	}

	while(true){
		ll N=in();
		if(!N) break;

		ll sum=0;
		REP(i,N){
			ll A=in(),B=in();
			ll L=max(A-B,1LL),R=A+B;
			sum += (S[R+1]-S[L])?S[R+1]-S[L]-1:-1;
		}
		out(sum);
	}
	
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 34664
final_rank: 19

code_snippet: #include <iostream>
#include <vector>
#include <cmath>
#include <string>
#include <algorithm>
#include <iomanip>
#include <map>
#include <bitset>
#include <cstdio>
#include <set>
#include <stack>
#include <queue>
#include <cassert>
#include <numeric>
#define rep(i,n) Rep(i,0,n)
#define Rep(i,k,n) for(int i=k ; i<n ; i++)
#define rep1(i,n) for(int i=1 ; i<=n ; i++)
#define Rep1(i,k,n) for(int i=k ; i<=n ; i++)
#define rrep(i,n) for(int i=n ; i>=0 ; i--)
#define vi vector<int>
#define vii vector<vector<int>>
#define mii map<int,int>
#define Sort(v) sort(v.begin(),v.end())
#define Reverse(v) reverse(v.begin(),v.end())
#define ALL(a)  (a).begin(),(a).end()
#define pb push_back
#define mp make_pair
//#define int ll
typedef long long ll;

const int md = 1000000007;
const int INF = 1<<30;
using namespace std;

//vi prime(1000000,0);
vector<bool> isp;

void makePrime(int n){
    isp.assign(n+1,true);
    int id = 0;
    for(int i=2 ; i <= n ; i++){
        if(!isp[i]) continue;

        for(int k = i*2 ; k <= n ; k += i){
            isp[k] = false;
        }
        /*
        prime[id] = i;
        id++;
        */
        
        //prime.pb(i);
    }
    //Sort(prime);
}

ll check(int a, int b){
    ll ans = 0;
    if(a-b <= 2) ans++;
    int s;
    if((a-b)%2 == 0) s = a-b+1;
    else s = a - b;

    for(int i = max(s,3); i <= min(a+b,999983) ; i += 2) {
        if(isp[i]) ans++;
    }
    return ans;
}
int main(){
    makePrime(999983);
    //cout << prime.size() << endl;
    //cout << binary_search(ALL(prime),2) << endl;
    int n; 
    while(true){
        cin >> n;
        if(n == 0) break;
        ll ans = 0;
        rep(i,n){
            int a,b; cin >> a >> b;
            //cout << check(a,b) << endl;
            int tmp = check(a,b);
            //cout << "check: " <<  tmp << endl;
            ans += check(a,b)-1;
            
        }
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 900
memory_kb: 3220
final_rank: 17

code_snippet: #include<iostream>
#include<set>
using namespace std;

bool nonprime[1000001] = {};
int accum[1000001] = {};
int scoresheet[1000001];

int main(){
    nonprime[0] = nonprime[1] = true;
    for(int i = 2; i <= 1000000; i++){
        if(!nonprime[i]){
            for(int j = i+i; j <= 1000000; j+=i){
                nonprime[j] = true;
            }
        }
    }

    for(int i = 2; i <= 1000000; i++){
        if(nonprime[i-1]){
            accum[i] = accum[i-1];
        }else{
            accum[i] = accum[i-1] + 1;
        }
    }

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

        for(int i = 0; i <= 1000000; i++)   scoresheet[i] = 0;

        set<int> result;
        int ans = 0;

        for(int i = 0; i < n; i++){
            int p, m;
            cin >> p >> m;

            int cnt = accum[min(p+m, 1000000)] - accum[max(0, p-m)];
            if(p+m <= 1000000 && !nonprime[p+m])    cnt++;

            result.insert(p);
            scoresheet[p] += cnt;

            if(cnt == 0)    ans--;
            else            ans += cnt-1;
        }
/*
        for(set<int>::iterator it = result.begin(); it != result.end(); it++){
            int x = scoresheet[*it];
            if(x == 0)   ans--;
            else         ans += x-1;
        }
*/
        cout << ans << endl;
    }

    return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 11936
final_rank: 12

code_snippet: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;

#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e9 + 7;
const ll MOD = 1e9 + 7;

#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define REP(i,N) for(long long i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second

int n;

bool is_prime[2000100];
int cnt[2000100];

int main(){
	fill(is_prime, is_prime + 1000000, 1);
	is_prime[0] = 0;
	is_prime[1] = 0;
	for (int i = 2; i <= (int)1e6; i++){
		if (is_prime[i]){
			for (int j = i * 2; j <= (int)1e6; j += i){
				is_prime[j] = 0;
			}
		}
	}
	FOR(i, 1, 2000000+10){
		if (is_prime[i])cnt[i]++;
		cnt[i] += cnt[i - 1];
	}
	//REP(i, 10){
	//	cout << i << " " << cnt[i] << endl;
	//}
	//for (int i = 999983 - 20; i <= 999983 + 20; i++){
	//	cout << i << " " << cnt[i] << endl;
	//}
	while (cin >> n&&n){
		int ans = 0;
		REP(i, n){
			int p, m;
			cin >> p >> m;
			int x = cnt[p + m];
			if (p - m - 1 >= 0)x -= cnt[p - m - 1];
			ans += (x - 1);
		}
		cout << ans << endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 11784
final_rank: 11

code_snippet: #include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

int N;
int BIT[6000000];

void add(int a, int w){
	
	// a?????????????´????w????¶???? O(log N)
	
	for(int x = a; x <= N; x += x & -x){
		BIT[x] += w;
	}
}

int sum(int a){
	
	// 1??????a?????§???????´????????¨?????????? O(log N)
	
	int ret = 0;
	for(int x = a; x > 0; x -= x & -x){
		ret += BIT[x];
	}
	return ret;
}

int main(){
	
	N = 2000000;
	int num_max = 1000000;
	
	bool a[1000000];
	
	for(int i = 0; i < num_max; i++){
		a[i] = true;
	}
	
	a[0] = false;
	a[1] = false;
	
	for(int i = 2; i < num_max; i++){
		if(a[i]){
			for(int j = i * 2; j < num_max; j += i){
				a[j] = false;
			}
		}
	}
	
	for(int i = 0; i < 6000000; i++){
		BIT[i] = 0;
	}
	
	for(int i = 0; i < num_max; i++){
		if(a[i]){
			add(i, 1);
		}
	}
	
	while(true){
		
		int n;
		
		cin >> n;
		
		if(n == 0){
			break;
		}
		
		int ans = 0;
		
		for(int i = 0; i < n; i++){
			int p, m, hit_num;
			cin >> p >> m;
			if(p - m <= 2){
				hit_num = sum(p + m);
			}else{
				hit_num = sum(p + m) - sum(p - m - 1);
			}
			
			//cout << hit_num << endl;
			
			ans = ans + hit_num - 1;
			
		}
		
		if(ans < 0){
			ans = 0;
		}
		
		cout << ans << endl;
		
	}
	
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 27396
final_rank: 16

code_snippet: #include "bits/stdc++.h"
using namespace std;

vector<int>primes(1e6+1);
vector<int>sums(1e6 + 1);
void hurui(const int amax) {
	static bool flag = false;
	if (flag)return;
	vector<int>sos;
	sos = vector<int>(amax + 1, true);
	sos[0] = false; sos[1] = false;
	for (int i = 2; i <= amax; ++i) {
		if (sos[i]) {
			for (int j = 2 * i; j <= amax; j += i)sos[j] = false;
		}
	}
	for (int i = 0; i <= amax; ++i) {
		if (sos[i]) {
			primes[i] = true;
		}
	}
	flag = true;
}


int main() {
	hurui(999983);
	for (int i = 0; i <1e6; ++i) {
		sums[i + 1] = sums[i] + primes[i + 1];
	}
	while (1) {
		int N; cin >> N;
		if (!N)break;
		long long int prize = 0;
		while (N--) {
			long long int p, m; cin >> p >> m;
			int amax = min(999983ll, p + m);
			int amin = max(0ll, p - m-1);
			const int aprize = sums[amax] - sums[amin];
			prize += aprize - 1;
		}
		cout << max(0ll,prize )<< endl;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 14180
final_rank: 15

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

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define INF (1<<29)

vector<bool> used;
long long sum[1000001];

int main() {
	used.resize(1000001, false);
	used[0] = used[1] = true;
	for (int i = 2; i * i <= 1000001; i++) {
		if (!used[i]) {
			sum[i]++;;
			for (int j = i; j <= 1000001; j += i) used[j] = true;
		}
	}
	REP(i, 1000001) if (!used[i]) sum[i]++;
	
	FOR(i, 1, 1000001) sum[i] += sum[i - 1];
	
	int n;
	while (cin >> n, n) {
		long long ans = 0;
		REP(i, n) {
			int p, m;
			scanf("%d %d", &p, &m);
			
			int a = p - m < 0 ? 0 : p - m - 1;
			int b = p + m > 1000001 ? 1000000 : p + m;
			
			int cnt = sum[b] - sum[a];
			if (cnt == 0) ans--;
			else ans += cnt - 1;
		}
		cout << ans << endl;
	}
	
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 9176
final_rank: 10

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

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define INF (1<<29)

vector<int> prime;
vector<bool> used;

int main() {
	used.resize(1000001, false);
	used[0] = used[1] = true;
	prime.push_back(-INF);
	for (int i = 2; i * i <= 1000001; i++) {
		if (!used[i]) {
			prime.push_back(i);
			for (int j = i; j <= 1000001; j += i) used[j] = true;
		}
	}
	REP(i, 1000001) if (!used[i]) prime.push_back(i);
	
	int n;
	while (cin >> n, n) {
		long long ans = 0;
		REP(i, n) {
			int p, m;
			scanf("%d %d", &p, &m);
			vector<int>::iterator it1 = upper_bound(prime.begin(), prime.end(), p + m) - 1;
			vector<int>::iterator it2 = upper_bound(prime.begin(), prime.end(), p - m) - 1;
			int cnt;
			
			if (*it1 < p - m) {
				if (*(it1 + 1) > p + m) it1 = prime.end();
				else it1++;
			}
			if (*it2 < p - m) {
				if (*(it2 + 1) > p + m) it2 = prime.end();
				else it2++;
			}
			
			if (it1 == prime.end() || it2 == prime.end())
				cnt = 2 - (it1 == prime.end()) - (it2 == prime.end()); 
			else
				cnt = it1 - it2 + 1;
			
			if (cnt == 0) ans--;
			else ans += cnt - 1;
		}
		cout << ans << endl;
	}
	
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 1712
final_rank: 1

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
bool p[1000000];
int prime[80000];
int top;
int F(int p,int m){
	int left,right,midl,midr;
	left=0,right=top;
	while(true){
		if(left>=right-1)break;
		midl=(left+right)/2;
		if(prime[midl]<p-m)left=midl;
		else right=midl;
	}
	if(prime[midl]>=p-m)midl--;
	if(p-m<=2)midl=-1;
	left=0,right=top;
	while(true){
		if(left>=right-1)break;
		midr=(left+right)/2;
		if(prime[midr]==p+m)break;
		if(prime[midr]<p+m)left=midr;
		else right=midr;
	}
	if(prime[midr]>p+m)midr--;
	//cout<<"%"<<prime[midl]<<" "<<prime[midr]<<endl;
	return midr-midl;
}
int main(){
	for(int i=0;i<1000000;i++)p[i]=true;
	for(int i=2;i<1000;i++)if(p[i])for(int j=i*i;j<1000000;j+=i)p[j]=false;
	top=0;
	for(int i=2;i<1000000;i++)if(p[i]){prime[top]=i;top++;}
	int n,p,m,ans;
	while(true){
	cin>>n;
	if(n==0)break;
	ans=0;
	for(int u=0;u<n;u++){
		cin>>p>>m;
		ans+=F(p,m)-1;
		//cout<<"#"<<F(p,m)<<endl;
	}
	cout<<ans<<endl;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 2444
final_rank: 2

code_snippet: #include<iostream>
#include<algorithm>
using namespace std;
int x[2000000];

void prime(int p) {
	x[2] = 1;
	for (int i = 3; i < p; i += 2) {
		for (int j = 3; j * j <= i; j += 2) {
			if (i%j == 0) { goto E; }
		}
		x[i] = 1;
	E:;
	}
}

int n, m, c, sum;

int main() {
	prime(1000000);
	while (true) {
		sum = 0;
		cin >> n;
		if (n == 0) { break; }
		for (int i = 0; i < n; i++) {
			cin >> m >> c;
			for (int j = max(0, m - c); j <= min(1000000, m + c); j++) {
				sum += x[j];
			}
			sum -= 1;
		}
		cout << sum << endl;
	}
}
accuracy: 1
time_ms: 820
memory_kb: 7016
final_rank: 18

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

#define MP 999983

int main() {
	vector<int> data(MP+1, 0);
	data[0] = data[1] = 1;
	vector<int> data2;
	for (int i = 2; i*i <= MP; i++) {
		if (data[i] == 0) {
			for (int j = 2; i*j <= MP; j++) {
				data[i*j] = 1;
			}
		}
	}
	for (int i = 0; i <= MP; i++) {
		if (data[i] == 0) {
			data2.push_back(i);
		}
	}
	int n;
	while (cin >> n) {
		if (n == 0) {
			break;
		}
		int p, m;
		int counter2 = 0;
		for (int i = 0; i < n; i++) {
			cin >> p >> m;
			int ma, mi;
			ma = min(p+m, MP);
			mi = max(p-m, 0);
			vector<int>::iterator ite = lower_bound(data2.begin(), data2.end(), mi);
			vector<int>::iterator ite2 = upper_bound(data2.begin(), data2.end(), ma);
			//cout << ite2-ite << endl;
			counter2 += ite2-ite-1;
		}
		cout << counter2 << endl;
	}
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5500
final_rank: 6

code_snippet: #include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <stack>
#include <queue>
 
using namespace std;
 
#define pb(n)	push_back(n)
#define mp(n,m) make_pair(n,m)
#define fi 	first
#define se 	second
#define all(r) (r).begin(),(r).end()
 
#define REP(i,s,e)	for(int i=(s); i<(e); i++)
#define rep(i,n)	REP(i,0,n)
#define REPE(i,s,e)	for(int i=s; i>e; i--)
#define repe(i,n)	REPE(i,n,-1)

typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
 
typedef vector<vi> vii;
 
const int IMAX=((1<<30)-1)*2+1;
const int INF=100000000;
const double EPS=1e-10;
//int mod=1000000007
 

 

int MP=999983;

vi is_prime(MP+1,1);
vi sum_prime(MP+1,0);


void set_prime(){
	is_prime[0]=is_prime[1]=0;
	for(int i=2; i<=MP; i++){
		if(is_prime[i]){
			for(int j=i*2; j<MP; j+=i){
				is_prime[j]=0;
			}
		}
		sum_prime[i]=sum_prime[i-1]+is_prime[i];
	}
}

int main(){
	set_prime();
	int n,p,m;
	int x;
	while(cin>>n && n>0){
		int ans=0;

		rep(i,n){
			cin>>p>>m;
			x=(p+m>MP?sum_prime[MP]:sum_prime[p+m])-(p-m-1>0?sum_prime[p-m-1]:0);
			if(x==0) ans--;
			else{
				ans+=x-1;
			}
		}
		cout<<ans<<endl;
	}
}
accuracy: 1
time_ms: 10
memory_kb: 8796
final_rank: 9

code_snippet: #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <bitset>
#include <unordered_set>
#include <unordered_map>
#include <fstream>
#include <iomanip>
//#include <utility>
//#include <memory>
//#include <functional>
//#include <deque>
//#include <cctype>
//#include <ctime>
//#include <numeric>
//#include <list>
//#include <iomanip>

//#if __cplusplus >= 201103L
//#include <array>
//#include <tuple>
//#include <initializer_list>
//#include <forward_list>
//
//#define cauto const auto&
//#else

//#endif

using namespace std;


typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;

#define VV(T) vector<vector< T > >

template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
    v.assign(a, vector<T>(b, t));
}

template <class F, class T>
void convert(const F &f, T &t){
    stringstream ss;
    ss << f;
    ss >> t;
}

#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x)  cout << #x << " = " << (x) << endl;
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#else
#define dump(x) 
#define debug(x) 
#endif
#define LDcout(x,n) fixed<<setprecision(n)<<x

#define MOD 1000000007LL
#define EPS 1e-8
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
#define maxs(x,y) x=max(x,y)
#define mins(x,y) x=min(x,y)
bool prime[1000000];
int a[1000000];
void mainmain(){
    int n;
    rep(i,1000000){
        prime[i]=true;
    }
    prime[0]=prime[1]=false;
    for(int i=2;i*i<=1000000;i++){
        if(prime[i]){
            for(int j=i*i;j<1000000;j+=i){
                prime[j]=false;
            }
        }
    }
    rep(i,1000000){
        if(!i) continue;
        a[i]=a[i-1];
        if(prime[i]) a[i]++;
    }
    while(cin>>n){
        if(!n) return;
        ll ans=0;
        rep(i,n){
            int x,y;
            cin>>x>>y;
            int l=max(1,x-y);
            int r=min(1000000-1,x+y);
            int t=a[r]-a[l-1]-1;
            // cout<<x<<" "<<y<<" "<<t<<" "<<l<<" "<<r<<endl;
            ans+=t;
        }
        cout<<ans<<endl;
    }
}


signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
      cout<<fixed<<setprecision(20);
    mainmain();
}
accuracy: 1
time_ms: 10
memory_kb: 6076
final_rank: 8

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

int prime[999985];
int main()
{
  fill_n(prime, 999985, 1);
  prime[1] = 0;
  for(int i = 2; i * i <= 999985; i++) {
    if(prime[i]) {
      for(int j = i + i; j <= 999985; j += i) {
        prime[j] = 0;
      }
    }
  }
  for(int i = 1; i <= 999985; i++) {
    prime[i] += prime[i - 1];
  }

  int n;
  while(scanf("%d", &n), n) {
    long long ret = 0LL;
    for(int i = 0; i < n; i++) {
      int p, m;
      scanf("%d %d", &p, &m);
      int low = max(1, p - m);
      int high = min(999984, p + m);
      ret += prime[high] - prime[low - 1] - 1;
    }
    printf("%d\n", ret);
  }
}
accuracy: 1
time_ms: 10
memory_kb: 5092
final_rank: 4

code_snippet: #include<bits/stdc++.h>
using namespace std;
const int S=1000001;

bool f[S];
int im[S];

int main(){

    fill_n(f,S,true);
    f[0]=f[1]=false;

    for(int i=2;i<S;i++){
        if(f[i])im[i]++;
        im[i]+=im[i-1];
        if(!f[i])continue;
        for(int j=2;i*j<S;j++)f[i*j]=false;
    }

    int n;
    while(cin>>n,n){
        int ans=0;
        while(n--){
            int p,m;
            cin>>p>>m;
            int v=im[min(S-1,p+m)]-im[max(0,p-m-1)];
            ans+=v-1;
        }

        cout<<max(0,ans)<<endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 6044
final_rank: 7

code_snippet: #include <bits/stdc++.h>

using namespace std;

const int MAX = 999984;
vector<int> v;
bool prime[MAX];

void sieve(){
    fill(prime, prime+MAX, true);
    prime[0] = prime[1] = false;

    for(int i=0; i < MAX; i++){
        if(!prime[i]) continue;
        v.push_back(i);
        for(int j=i+i; j < MAX; j += i){
            prime[j] = false;
        }
    }
}

int main(){
    sieve();
    int n;
    while(cin >> n, n){
        int ans = 0;
        for(int i=0; i< n; i++){
            int a, b;
            cin >> a >> b;
            int p = lower_bound(v.begin(), v.end(), a+b+1) - lower_bound(v.begin(), v.end(), a-b);
            ans += p;
        }
        ans -= n;
        cout << ans << endl;
    }
}
accuracy: 1
time_ms: 10
memory_kb: 2564
final_rank: 3

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

int prime[1000001];

int main()
{
	for (int i = 2; i <= 1000000; i++){
		prime[i] = 1;
	}
	for (int i = 2; i * i <= 1000000; i++){
		for (int j = i * i; j <= 1000000; j += i){
			prime[j] = 0;
		}
	}
	for (int i = 1; i <= 1000000; i++){
		prime[i] += prime[i - 1];
	}
	
	int n;
	while (scanf("%d", &n), n){
		int res = 0;
		for (int i = 0; i < n; i++){
			int p, m;
			scanf("%d %d", &p, &m);
			int x = prime[min(p + m, 1000000)] - prime[max(p - m - 1, 0)];
			res += x ? x - 1 : -1;
		}
		printf("%d\n", res);
	}
	
	return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 5092
final_rank: 4

code_snippet: #include <cstdio>
#include <iostream>
using namespace std;

const long N=1000000;

int main(){
	bool prime[N+1];
	
	for(long i=0; i<=N; ++i) prime[i]=true;
	prime[0]=prime[1]=false;
	for(long i=2; i<=N; ++i){
		if(prime[i]) for(long j=2; i*j<=N; ++j) prime[i*j]=false;
	}
	
	while(1){
		int n;
		scanf(" %d", &n);
		if(n==0) break;
		
		long ans=0;
		for(int i=0; i<n; ++i){
			long p, m;
			scanf(" %ld %ld", &p, &m);	
			
			long x=0;
			int y=0;
			if((p+m)%2==0) y=1;
			
			if(p-m<=2) ++x;
			
			for(long j=p-m+y; j<=p+m-y; j+=2){
				//printf("j=%ld\n", j);
				if(j<2) continue;
				if(j>N) break;
				
				if(prime[j]) x++;
			}
			
			ans+=x-1;
			//printf("%ld\n", ans);
		}	
		
		printf("%ld\n", ans);
	}
}
accuracy: 1
time_ms: 1000
memory_kb: 2160
final_rank: 20