Problem:
C: 素数
問題
ある日、素数が大好きなそすうさ君は $p + q$ が素数となるペア $(p, q)$ で遊んでいた。
  そすうさ君は突然、このペアのうち、 $p$ と $q$ がともに $N$ 以下の素数であるペアがいくつあるか気になりだした。
  そすうさ君に代わって個数を求めよ。
制約
入力値は全て整数である。
$1 \leq N \leq 10^7$
入力形式
入力は以下の形式で与えられる。
$N$
出力
ペアの個数を出力せよ。また、末尾に改行も出力せよ。
サンプル
サンプル入力 1
3
サンプル出力 1
2
ペアは $(2, 3), (3, 2)$ の二つである。
サンプル入力 2
20
サンプル出力 2
8

Submitted solutions:

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 10000005
bool is_prime[NUM];

int main(){

	for(int i = 0; i < NUM; i++){
		is_prime[i] = true;
	}

	is_prime[0] = false;
	is_prime[2] = false;

	//偶数
	for(int i = 4; i < NUM; i += 2){
		is_prime[i] = false;
	}

	for(int i = 3; i < NUM; i += 2){
		if(!is_prime[i])continue;
		for(int k = 2*i; k < NUM; k += i){
			is_prime[k] = false;
		}
	}

	int N;

	scanf("%d",&N);

	if(N <= 2){
		printf("0\n");
		return 0;
	}

	int ans = 0;
	for(int i = 3; i <= N; i += 2){
		if(!is_prime[i])continue;
		if(is_prime[i+2]){
			ans++;
		}
	}

	ans *= 2;

	printf("%d\n",ans);

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 13324
final_rank: 10

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

/*
*/

using namespace std;
//make -f ../makefile SRC=

/*
TODO

*/

//------------------------------------------------------------------------------
bool DEBUG = false;

const int MAX_V = 10000000;
static bool is_prime[MAX_V+3];

//------------------------------------------------------------------------------
void sieve_of_eratosthenes()
{
    is_prime[0] = false;
    is_prime[1] = false;

    for (int i=2; i<=MAX_V; i++) is_prime[i] = true;

    for (int i=2; i*i<=MAX_V; i++)
    {
        if (is_prime[i])
        {
            for (int j=2*i; j<=MAX_V; j+=i) is_prime[j] = false;
        }
    }
}

//------------------------------------------------------------------------------
int solve(int N)
{
    if (DEBUG) printf("N=%d\n", N);
    //--------------------------------------------------------------------------
    // base cases:
    if (N < 3) return 0;
    else if (N == 3) return 2;
    //--------------------------------------------------------------------------
    // init:
    int res = 0;
    for (int i=3; i<=N; ++i)
        if (is_prime[i] && is_prime[i+2])
            res++;

    return 2*res;
}

//------------------------------------------------------------------------------
int main()
{
    //DEBUG = true;
    sieve_of_eratosthenes();
    //test(); return 0;
    //--------------------------------------------------------------------------
    int N, num;
    num = scanf("%d ", &N);
    int res = solve(N);
    printf("%d\n", res);
    //--------------------------------------------------------------------------
    return 0;
}
//------------------------------------------------------------------------------
accuracy: 1
time_ms: 30
memory_kb: 13320
final_rank: 7

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

int main() {
    int N;
    std::cin >> N;
    std::vector<bool> prime(N + 3, true);
    prime[0] = prime[1] = false;
    for (long long i{2} ; i * i <= N + 2 ; i++) {
        if (!prime[i]) continue;
        for (long long j{i * i} ; j <= N + 2 ; j += i) {
            prime[j] = false;
        } 
    }
    int ans{};
    for (int i{} ; i <= N ; i++) {
        ans += 2 * (prime[i] and prime[i + 2]);
    }
    std::cout << ans << '\n';
}
accuracy: 1
time_ms: 30
memory_kb: 4192
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;
int main(){
    int n;
    cin>>n;
    vector<bool>isp(n+10,true);
    isp[0]=isp[1]=false;
    for(int i=2;i<n+10;i++)if(isp[i]){
        for(int j=2;i*j<=n+10;j++)isp[i*j]=false;
    }
    vector<int>prime;
    for(int i=0;i<n+10;i++)if(isp[i])prime.push_back(i);
    int ans=0;
    for(int i=0;i<prime.size();i++)if(prime[i]<=n){
        if(isp[prime[i]+2])ans+=2;
    }
    cout<<ans<<endl;
}
accuracy: 1
time_ms: 50
memory_kb: 10124
final_rank: 8

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

int main() {
    int n;
    std::cin >> n;
    const int N = n + 10;
    std::vector<int> prime(N + 1, 1);
    prime[0] = 0;
    prime[1] = 0;
    for (long long i = 2; i * i <= N; i++) {
        if (prime[i]) {
            for (long long j = i * i; j <= N; j += i) {
                prime[j] = 0;
            }
        }
    }
    if (n <= 2) {
        std::cout << 0 << std::endl;
        return 0;
    }
    int ans = 0;
    for (int i = 3; i <= n; i++) {
        if (prime[i] && prime[i + 2]) {
            assert(prime[2]);
            assert(prime[i]);
            assert(prime[i + 2]);
            ans++;
        }
    }
    std::cout << 2 * ans << std::endl;
}
accuracy: 1
time_ms: 70
memory_kb: 42204
final_rank: 14

code_snippet: #include<bits/stdc++.h>
using namespace std;
bool sosu[10000002];
int main(){
    int n;
    cin >> n;
    memset(sosu, true, sizeof(sosu));
    for(int i=3;i<=10000002;i+=2){
        if(!sosu[i] || i>3300) continue;
        for(int j=i*i;j<=10000002;j+=i){
            sosu[j] = false;
        }
    }
    int ans = 0;
    for(int i=3;i<=n;i+=2){
        if(sosu[i] && sosu[i+2]) ans+=2;
    }
    cout << ans << endl;
    return(0);
}
accuracy: 1
time_ms: 40
memory_kb: 12840
final_rank: 9

code_snippet: #include<bits/stdc++.h>
using namespace std;
bool sosu[9000009];
int main(){
    int n;
    cin >> n;
    memset(sosu, true, sizeof(sosu));
    for(int i=3;i<=9000009;i+=2){
        if(!sosu[i] || i>3000) continue;
        for(int j=i*i;j<=9000009;j+=i){
            sosu[j] = false;
        }
    }
    int ans = 0;
    for(int i=3;i<=n;i+=2){
        if(sosu[i] && sosu[i+2]) ans+=2;
    }
    cout << ans << endl;
    return(0);
}
accuracy: 0.5882352941176471
time_ms: 30
memory_kb: 11864
final_rank: 18

code_snippet: #include<bits/stdc++.h>
using namespace std;
bool sosu[5000005];
int main(){
    int n;
    cin >> n;
    memset(sosu, true, sizeof(sosu));
    for(int i=3;i<=5000005;i+=2){
        if(!sosu[i] || i>3000) continue;
        for(int j=i*i;j<=5000005;j+=i){
            sosu[j] = false;
        }
    }
    int ans = 0;
    for(int i=3;i<=n;i+=2){
        if(sosu[i] && sosu[i+2]) ans+=2;
    }
    cout << ans << endl;
    return(0);
}
accuracy: 0.38235294117647056
time_ms: 10
memory_kb: 7956
final_rank: 19

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
#define all(A) A.begin(),A.end()
#define rep(i, n) for (ll i = 0; i < (ll) (n); i++)

int main() {
    ll A=1e7+10;
    vector<bool> P(A,1);
    P[0]=P[1]=0;
    rep(i,A)if(P[i])for(ll j=i*2;j<A;j+=i)P[j]=0;
    ll an=0;
    ll N;
    cin>>N;
    rep(i,N+1){
        if(P[i]&&P[i+2])an++;
    }
    cout<<an*2<<endl;
}
accuracy: 1
time_ms: 50
memory_kb: 4244
final_rank: 5

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

using namespace std;

typedef long long ll;
typedef pair<int,int> P;
#define REP(i,n) for(int i=0;i<int(n);i++)

int p[10000010];

void sieve(int n){
	int i,j;
	for(i=2;i<=n;i++) p[i]=1;
	for(i=2;i<=n;i++){
		if(p[i]){
			for(j=2*i;j<=n;j+=i) p[j]=0;
		}
	}
}


int main(void){
	cin.tie(nullptr);  ios_base::sync_with_stdio(false);
	int i;

	int n;
	cin >> n;
	sieve(n+2);

	int ans=0;
	for(i=3;i<=n;i++){
		if(p[i]==0) continue;
		if(p[i+2]==1) ans+=2;
	}

	cout << ans << endl;

	return 0;
}
accuracy: 1
time_ms: 120
memory_kb: 42500
final_rank: 15

code_snippet: #include <iostream>
#include <algorithm>
#include <string>
#include <cmath>
#include <vector>
#include <iomanip>
#include <random>
#include <climits>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <thread>
#include <chrono>
#include <ctime>
#include <deque>
#include <sstream>
#include <bitset>

using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;//Graph(n) n:頂点数

struct Edge {
	int to;
	int weight;
	Edge(int t, int w) :to(t), weight(w) {}
};

using WGraph = vector<vector<Edge>>;

template<class T> void chmin(T& a, T b) {
	if (a > b)a = b;
}
template<class T> void chmax(T& a, T b) {
	if (a < b)a = b;
}

/*

*/

struct UnionFind {
	vector<int> par, siz;
	UnionFind(int n) :par(n, -1), siz(n, 1) {}
	int root(int x) {
		if (par[x] == -1)return x;
		return par[x] = root(par[x]);
	}
	bool issame(int x, int y) {
		return root(x) == root(y);
	}
	bool unite(int x, int y) {
		x = root(x);
		y = root(y);
		if (siz[x] < siz[y])swap(x, y);
		par[y] = x;
		siz[x] += siz[y];
		return true;
	}
	int size(int x) {
		return siz[root(x)];
	}
};



int main() {

	constexpr int siz = 10000003;

	vector<bool> primeset(siz);
	primeset.flip();
	primeset[0] = false;
	primeset[1] = false;

	for (int i = 2; i < siz; ++i) {
		if (primeset[i]) {
			for (int j = i + i; j < siz; j += i) {
				primeset[j] = false;
			}
		}
	}

	int n;
	cin >> n;

	int ans = 0;

	for (int i = 0; i <= n; ++i) {
		if (primeset[i] and primeset[i + 2]) {
			++ans;
		}
	}

	cout << ans * 2 << endl;

	

	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 4300
final_rank: 6

code_snippet: #line 2 "/home/yuruhiya/programming/library/template/template.cpp"
#include <bits/stdc++.h>
#line 4 "/home/yuruhiya/programming/library/template/constants.cpp"
#include <string_view>
#line 7 "/home/yuruhiya/programming/library/template/constants.cpp"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rfor(i, m, n) for (int i = (m); i >= (n); --i)
#define unless(c) if (!(c))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define range_it(a, l, r) (a).begin() + (l), (a).begin() + (r)

using namespace std;
using ll = long long;
using LD = long double;
using VB = vector<bool>;
using VVB = vector<VB>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VS = vector<string>;
using VD = vector<LD>;
using PII = pair<int, int>;
using VP = vector<PII>;
using PLL = pair<ll, ll>;
using VPL = vector<PLL>;
template <class T> using PQ = priority_queue<T>;
template <class T> using PQS = priority_queue<T, vector<T>, greater<T>>;
constexpr int inf = 1000000000;
constexpr long long inf_ll = 1000000000000000000ll, MOD = 1000000007;
constexpr long double PI = 3.14159265358979323846, EPS = 1e-12;
namespace CharacterClass {
	constexpr string_view
	    digit = "0123456789",
	    xdigit = "0123456789ABCDEFabcdef", lower = "abcdefghijklmnopqrstuvwxyz",
	    upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
	    alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
	    alnum = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
	    word = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
	    punct = R"(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)",
	    graph =
	        R"(!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)",
	    print =
	        R"( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)",
	    blank = " \t", space = " \t\n\r\f\v";
}  // namespace CharacterClass
#line 7 "/home/yuruhiya/programming/library/template/Input.cpp"
using namespace std;

#ifdef _WIN32
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#define fwrite_unlocked fwrite
#define fflush_unlocked fflush
#endif
class Scanner {
	static int gc() {
		return getchar_unlocked();
	}
	static char next_char() {
		char c;
		read(c);
		return c;
	}
	template <class T> static void read(T& v) {
		cin >> v;
	}
	static void read(char& v) {
		while (isspace(v = gc()))
			;
	}
	static void read(bool& v) {
		v = next_char() != '0';
	}
	static void read(string& v) {
		v.clear();
		for (char c = next_char(); !isspace(c); c = gc()) v += c;
	}
	static void read(int& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(long long& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(double& v) {
		v = 0;
		double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	static void read(long double& v) {
		v = 0;
		long double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	template <class T, class U> static void read(pair<T, U>& v) {
		read(v.first);
		read(v.second);
	}
	template <class T> static void read(vector<T>& v) {
		for (auto& e : v) read(e);
	}
	template <size_t N = 0, class T> static void read_tuple_impl(T& v) {
		if constexpr (N < tuple_size_v<T>) {
			read(get<N>(v));
			read_tuple_impl<N + 1>(v);
		}
	}
	template <class... T> static void read(tuple<T...>& v) {
		read_tuple_impl(v);
	}
	struct ReadVectorHelper {
		size_t n;
		ReadVectorHelper(size_t _n) : n(_n) {}
		template <class T> operator vector<T>() {
			vector<T> v(n);
			read(v);
			return v;
		}
	};
	struct Read2DVectorHelper {
		size_t n, m;
		Read2DVectorHelper(const pair<size_t, size_t>& nm) : n(nm.first), m(nm.second) {}
		template <class T> operator vector<vector<T>>() {
			vector<vector<T>> v(n, vector<T>(m));
			read(v);
			return v;
		}
	};

public:
	string read_line() const {
		string v;
		for (char c = gc(); c != '\n' && c != '\0'; c = gc()) v += c;
		return v;
	}
	template <class T> T read() const {
		T v;
		read(v);
		return v;
	}
	template <class T> vector<T> read_vector(size_t n) const {
		vector<T> a(n);
		read(a);
		return a;
	}
	template <class T> operator T() const {
		return read<T>();
	}
	int operator--(int) const {
		return read<int>() - 1;
	}
	ReadVectorHelper operator[](size_t n) const {
		return ReadVectorHelper(n);
	}
	Read2DVectorHelper operator[](const pair<size_t, size_t>& nm) const {
		return Read2DVectorHelper(nm);
	}
	void operator()() const {}
	template <class H, class... T> void operator()(H&& h, T&&... t) const {
		read(h);
		operator()(forward<T>(t)...);
	}

private:
	template <template <class...> class, class...> struct Multiple;
	template <template <class...> class V, class Head, class... Tail>
	struct Multiple<V, Head, Tail...> {
		template <class... Args> using vec = V<vector<Head>, Args...>;
		using type = typename Multiple<vec, Tail...>::type;
	};
	template <template <class...> class V> struct Multiple<V> { using type = V<>; };
	template <class... T> using multiple_t = typename Multiple<tuple, T...>::type;
	template <size_t N = 0, class T> void multiple_impl(T& t) const {
		if constexpr (N < tuple_size_v<T>) {
			auto& vec = get<N>(t);
			using V = typename remove_reference_t<decltype(vec)>::value_type;
			vec.push_back(read<V>());
			multiple_impl<N + 1>(t);
		}
	}

public:
	template <class... T> auto multiple(size_t h) const {
		multiple_t<T...> result;
		while (h--) multiple_impl(result);
		return result;
	}
} in;
#define inputs(T, ...) \
	T __VA_ARGS__;     \
	in(__VA_ARGS__)
#define ini(...) inputs(int, __VA_ARGS__)
#define inl(...) inputs(long long, __VA_ARGS__)
#define ins(...) inputs(string, __VA_ARGS__)
#line 7 "/home/yuruhiya/programming/library/template/Output.cpp"
#include <charconv>
#line 10 "/home/yuruhiya/programming/library/template/Output.cpp"
using namespace std;

struct BoolStr {
	const char *t, *f;
	BoolStr(const char* _t, const char* _f) : t(_t), f(_f) {}
} Yes("Yes", "No"), yes("yes", "no"), YES("YES", "NO"), Int("1", "0");
struct DivStr {
	const char *d, *l;
	DivStr(const char* _d, const char* _l) : d(_d), l(_l) {}
} spc(" ", "\n"), no_spc("", "\n"), end_line("\n", "\n"), comma(",", "\n"),
    no_endl(" ", "");
class Output {
	BoolStr B{Yes};
	DivStr D{spc};

public:
	void put(int v) const {
		char buf[12]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void put(long long v) const {
		char buf[21]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void put(bool v) const {
		put(v ? B.t : B.f);
	}
	void put(vector<bool>::reference v) const {
		put(v ? B.t : B.f);
	}
	void put(char v) const {
		putchar_unlocked(v);
	}
	void put(const char* v) const {
		fwrite_unlocked(v, 1, strlen(v), stdout);
	}
	void put(double v) const {
		printf("%.20f", v);
	}
	void put(long double v) const {
		printf("%.20Lf", v);
	}
	template <class T> void put(const T& v) const {
		cout << v;
	}
	template <class T, class U> void put(const pair<T, U>& v) const {
		put(v.first);
		put(D.d);
		put(v.second);
	}
	template <class InputIterater>
	void put_range(const InputIterater& begin, const InputIterater& end) const {
		for (InputIterater i = begin; i != end; ++i) {
			if (i != begin) put(D.d);
			put(*i);
		}
	}
	template <class T> void put(const vector<T>& v) const {
		put_range(v.begin(), v.end());
	}
	template <class T, size_t N> void put(const array<T, N>& v) const {
		put_range(v.begin(), v.end());
	}
	template <class T> void put(const vector<vector<T>>& v) const {
		for (size_t i = 0; i < v.size(); ++i) {
			if (i) put(D.l);
			put(v[i]);
		}
	}

	Output() = default;
	Output(const BoolStr& _boolstr, const DivStr& _divstr) : B(_boolstr), D(_divstr) {}
	Output& operator()() {
		put(D.l);
		return *this;
	}
	template <class H> Output& operator()(H&& h) {
		put(h);
		put(D.l);
		return *this;
	}
	template <class H, class... T> Output& operator()(H&& h, T&&... t) {
		put(h);
		put(D.d);
		return operator()(forward<T>(t)...);
	}
	template <class InputIterator>
	Output& range(const InputIterator& begin, const InputIterator& end) {
		put_range(begin, end);
		put(D.l);
		return *this;
	}
	template <class T> Output& range(const T& a) {
		range(a.begin(), a.end());
		return *this;
	}
	template <class... T> void exit(T&&... t) {
		operator()(forward<T>(t)...);
		std::exit(EXIT_SUCCESS);
	}
	Output& flush() {
		fflush_unlocked(stdout);
		return *this;
	}
	Output& set(const BoolStr& b) {
		B = b;
		return *this;
	}
	Output& set(const DivStr& d) {
		D = d;
		return *this;
	}
	Output& set(const char* t, const char* f) {
		B = BoolStr(t, f);
		return *this;
	}
} out;
#line 3 "/home/yuruhiya/programming/library/template/Step.cpp"
using namespace std;

template <class T> struct Step {
	using value_type = T;

	class iterator {
		value_type a, b, c;

	public:
		constexpr iterator() : a(value_type()), b(value_type()), c(value_type()) {}
		constexpr iterator(value_type _b, value_type _c, value_type _s)
		    : a(_b), b(_c), c(_s) {}
		constexpr iterator& operator++() {
			--b;
			a += c;
			return *this;
		}
		constexpr iterator operator++(int) {
			iterator tmp = *this;
			--b;
			a += c;
			return tmp;
		}
		constexpr const value_type& operator*() const {
			return a;
		}
		constexpr const value_type* operator->() const {
			return &a;
		}
		constexpr bool operator==(const iterator& i) const {
			return b == i.b;
		}
		constexpr bool operator!=(const iterator& i) const {
			return !(b == i.b);
		}
		constexpr value_type start() const {
			return a;
		}
		constexpr value_type size() const {
			return b;
		}
		constexpr value_type step() const {
			return c;
		}
	};
	constexpr Step(value_type b, value_type c, value_type s) : be(b, c, s) {}
	constexpr iterator begin() const {
		return be;
	}
	constexpr iterator end() const {
		return en;
	}
	constexpr value_type start() const {
		return be.start();
	}
	constexpr value_type size() const {
		return be.size();
	}
	constexpr value_type step() const {
		return be.step();
	}
	constexpr value_type sum() const {
		return start() * size() + step() * (size() * (size() - 1) / 2);
	}
	operator vector<value_type>() const {
		return to_a();
	}
	auto to_a() const {
		vector<value_type> result;
		result.reserve(size());
		for (auto i : *this) {
			result.push_back(i);
		}
		return result;
	}

private:
	iterator be, en;
};
template <class T> constexpr auto step(T a) {
	return Step<T>(0, a, 1);
}
template <class T> constexpr auto step(T a, T b) {
	return Step<T>(a, b - a, 1);
}
template <class T> constexpr auto step(T a, T b, T c) {
	return Step<T>(a, a < b ? (b - a - 1) / c + 1 : 0, c);
}
#line 8 "/home/yuruhiya/programming/library/template/Ruby.cpp"
using namespace std;

template <class F> struct Callable {
	F func;
	Callable(const F& f) : func(f) {}
};
template <class T, class F> auto operator|(const T& v, const Callable<F>& c) {
	return c.func(v);
}

struct Sort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const Sort_impl& c) {
		sort(begin(v), end(v));
		return v;
	}
} Sort;
struct SortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) < f(j); });
			return v;
		});
	}
} SortBy;
struct RSort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(rbegin(v), rend(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const RSort_impl& c) {
		sort(rbegin(v), rend(v));
		return v;
	}
} RSort;
struct RSortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) > f(j); });
			return v;
		});
	}
} RSortBy;
struct Reverse_impl {
	template <class T> friend auto operator|(T v, const Reverse_impl& c) {
		reverse(begin(v), end(v));
		return v;
	}
} Reverse;
struct Unique_impl {
	template <class T> friend auto operator|(T v, const Unique_impl& c) {
		v.erase(unique(begin(v), end(v), end(v)));
		return v;
	}
} Unique;
struct Uniq_impl {
	template <class T> friend auto operator|(T v, const Uniq_impl& c) {
		sort(begin(v), end(v));
		v.erase(unique(begin(v), end(v)), end(v));
		return v;
	}
} Uniq;
struct Rotate_impl {
	auto operator()(int&& left) {
		return Callable([&](auto v) {
			int s = static_cast<int>(size(v));
			assert(-s <= left && left <= s);
			if (0 <= left) {
				rotate(begin(v), begin(v) + left, end(v));
			} else {
				rotate(begin(v), end(v) + left, end(v));
			}
			return v;
		});
	}
} Rotate;
struct Max_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *max_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Max_impl& c) {
		return *max_element(begin(v), end(v));
	}
} Max;
struct Min_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *min_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Min_impl& c) {
		return *min_element(begin(v), end(v));
	}
} Min;
struct MaxPos_impl {
	template <class T> friend auto operator|(T v, const MaxPos_impl& c) {
		return max_element(begin(v), end(v)) - begin(v);
	}
} MaxPos;
struct MinPos_impl {
	template <class T> friend auto operator|(T v, const MinPos_impl& c) {
		return min_element(begin(v), end(v)) - begin(v);
	}
} MinPos;
struct MaxBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_it = begin(v);
			auto max_val = f(*max_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_it = it;
					max_val = val;
				}
			}
			return *max_it;
		});
	}
} MaxBy;
struct MinBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_it = begin(v);
			auto min_val = f(*min_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_it = it;
					min_val = val;
				}
			}
			return *min_it;
		});
	}
} MinBy;
struct MaxOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_val = val;
				}
			}
			return max_val;
		});
	}
} MaxOf;
struct MinOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_val = val;
				}
			}
			return min_val;
		});
	}
} MinOf;
struct Count_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return count(begin(v), end(v), val); });
	}
} Count;
struct CountIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return count_if(begin(v), end(v), f); });
	}
} CountIf;
struct Index_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(begin(v), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} Index;
struct IndexIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} IndexIf;
struct FindIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<typename decltype(v)::value_type> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(*result) : nullopt;
		});
	}
} FindIf;
struct Sum_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			return accumulate(next(begin(v)), end(v), f(*begin(v)),
			                  [&](const auto& a, const auto& b) { return a + f(b); });
		});
	}
	template <class T> friend auto operator|(T v, const Sum_impl& c) {
		return accumulate(begin(v), end(v), typename T::value_type{});
	}
} Sum;
struct Includes {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return find(begin(v), end(v), val) != end(v); });
	}
} Includes;
struct IncludesIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return find_if(begin(v), end(v), f) != end(v); });
	}
} IncludesIf;
struct RemoveIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) {
			v.erase(remove_if(begin(v), end(v), f), end(v));
			return v;
		});
	}
} RemoveIf;
struct Each_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				f(i);
			}
		});
	}
} Each;
struct Select_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using value_type = typename decltype(v)::value_type;
			vector<value_type> result;
			for (const auto& i : v) {
				if (f(i)) result.push_back(i);
			}
			return result;
		});
	}
} Select;
struct Map_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using result_type = invoke_result_t<F, typename decltype(v)::value_type>;
			vector<result_type> result;
			result.reserve(size(v));
			for (const auto& i : v) {
				result.push_back(f(i));
			}
			return result;
		});
	}
} Map;
struct Indexed_impl {
	template <class T> friend auto operator|(const T& v, Indexed_impl& c) {
		using value_type = typename T::value_type;
		vector<pair<value_type, int>> result;
		result.reserve(size(v));
		int index = 0;
		for (const auto& i : v) {
			result.emplace_back(i, index++);
		}
		return result;
	}
} Indexed;
struct AllOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (!f(i)) return false;
			}
			return true;
		});
	}
} AllOf;
struct AnyOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return true;
			}
			return false;
		});
	}
} AnyOf;
struct NoneOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return false;
			}
			return true;
		});
	}
} NoneOf;

struct Tally_impl {
	template <class F> auto operator()(size_t max_val) {
		return Callable([&](auto v) {
			vector<size_t> result(max_val);
			for (const auto& i : v) {
				result[static_cast<size_t>(i)]++;
			}
			return result;
		});
	}
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, Tally_impl& c) {
		map<value_type, size_t> result;
		for (const auto& i : v) {
			result[i]++;
		}
		return result;
	}
} Tally;

template <class T> auto operator*(const vector<T>& a, size_t n) {
	T result;
	for (size_t i = 0; i < n; ++i) {
		result.insert(result.end(), a.begin(), a.end());
	}
	return result;
}
auto operator*(string a, size_t n) {
	string result;
	for (size_t i = 0; i < n; ++i) {
		result += a;
	}
	return result;
}
template <class T, class U> auto& operator<<(vector<T>& a, const U& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T> auto& operator<<(string& a, const T& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T, class U> auto operator+(vector<T> a, const U& b) {
	a << b;
	return a;
}
template <class T> auto operator+(string a, const T& b) {
	a << b;
	return a;
}
#line 7 "/home/yuruhiya/programming/library/template/functions.cpp"
using namespace std;

template <class T = long long> constexpr T TEN(size_t n) {
	T result = 1;
	for (size_t i = 0; i < n; ++i) result *= 10;
	return result;
}
template <class T, class U,
          enable_if_t<is_integral_v<T> && is_integral_v<U>, nullptr_t> = nullptr>
constexpr auto div_ceil(T n, U m) {
	return (n + m - 1) / m;
}
template <class T, class U> constexpr auto div_ceil2(T n, U m) {
	return div_ceil(n, m) * m;
}
template <class T> constexpr T triangle(T n) {
	return (n & 1) ? (n + 1) / 2 * n : n / 2 * (n + 1);
}
template <class T> constexpr T nC2(T n) {
	return (n & 1) ? (n - 1) / 2 * n : n / 2 * (n - 1);
}
template <class T, class U> constexpr auto middle(const T& l, const U& r) {
	return l + (r - l) / 2;
}
template <class T, class U, class V>
constexpr bool in_range(const T& v, const U& lower, const V& upper) {
	return lower <= v && v < upper;
}
template <class T, enable_if_t<is_integral_v<T>, nullptr_t> = nullptr>
constexpr bool is_square(T n) {
	T s = sqrt(n);
	return s * s == n || (s + 1) * (s + 1) == n;
}
template <class T = long long> constexpr T BIT(int b) {
	return T(1) << b;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Pow(T a, U n) {
	assert(n >= 0);
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result *= a;
			n--;
		} else {
			a *= a;
			n >>= 1;
		}
	}
	return result;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Powmod(T a, U n, T mod) {
	assert(n >= 0);
	if (a > mod) a %= mod;
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result = result * a % mod;
			n--;
		} else {
			a = a * a % mod;
			n >>= 1;
		}
	}
	return result;
}
template <class T> bool chmax(T& a, const T& b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> bool chmin(T& a, const T& b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> int sz(const T& v) {
	return v.size();
}
template <class T, class U> int lower_index(const T& a, const U& v) {
	return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int upper_index(const T& a, const U& v) {
	return upper_bound(all(a), v) - a.begin();
}
template <class T> auto Slice(const T& v, size_t i, size_t len) {
	return i < v.size() ? T(v.begin() + i, v.begin() + min(i + len, v.size())) : T();
}
template <class T, class U = typename T::value_type> U Gcdv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), gcd<U, U>);
}
template <class T, class U = typename T::value_type> U Lcmv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), lcm<U, U>);
}
namespace internal {
	template <class T, size_t N> auto make_vector(vector<int>& sizes, const T& init) {
		if constexpr (N == 1) {
			return vector(sizes[0], init);
		} else {
			int size = sizes[N - 1];
			sizes.pop_back();
			return vector(size, make_vector<T, N - 1>(sizes, init));
		}
	}
}  // namespace internal
template <class T, size_t N>
auto make_vector(const int (&sizes)[N], const T& init = T()) {
	vector s(rbegin(sizes), rend(sizes));
	return internal::make_vector<T, N>(s, init);
}
#line 9 "/home/yuruhiya/programming/library/template/template.cpp"
#if __has_include(<library/dump.hpp>)
#include <library/dump.hpp>
#define LOCAL
#else
#define dump(...) ((void)0)
#endif

template <class T> constexpr T oj_local(const T& oj, const T& local) {
#ifndef LOCAL
	return oj;
#else
	return local;
#endif
}
#line 3 "/home/yuruhiya/programming/library/Math/Eratosthenes.cpp"
using namespace std;

vector<bool> Eratosthenes(size_t n) {
	vector<bool> result(n + 1, true);
	result[0] = result[1] = false;
	for (size_t i = 2; i * i <= n; ++i) {
		if (result[i]) {
			for (size_t j = i * i; j <= n; j += i) result[j] = false;
		}
	}
	return result;
}
#line 3 "a.cpp"

int main() {
	ini(n);
	auto p = Eratosthenes(n + 3);
	int ans = 0;
	rep(i, n + 1) {
		ans += p[i] && p[i + 2];
	}
	out(ans * 2);
}
accuracy: 1
time_ms: 30
memory_kb: 4300
final_rank: 2

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

bool IsP[20050000];
ll N;
int main() {
    for(int i = 2; i <= 2e7; i++) {
        IsP[i] = true;
    }
    for(int i = 2; i <= 2e7; i++) {
        if(!IsP[i]) continue;
        for(int j = 2 * i; j <= 2e7; j += i) {
            IsP[j] = false;
        }
    }
    cin >> N;
    ll ans = 0;
    for(int i = 2; i <= N; i++) {
        if(IsP[i] and IsP[i+2]) ans++;
    }
    cout << ans * 2 << endl;
    return 0;
}
accuracy: 1
time_ms: 150
memory_kb: 22972
final_rank: 13

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

struct Prime {
    int max_n;
    std::vector<int> primes;
    std::vector<bool> isp;

    explicit Prime(int max_n)
        : max_n(max_n), isp(max_n + 1, true) {
        isp[0] = isp[1] = false;
        for (int i = 2; i * i <= max_n; ++i) {
            if (isp[i]) {
                for (int j = i; i * j <= max_n; ++j) {
                    isp[i * j] = false;
                }
            }
        }

        for (int p = 2; p <= max_n; ++p) {
            if (isp[p]) primes.push_back(p);
        }
    }

    template <class T>
    bool isprime(T n) const {
        if (n <= max_n) return isp[n];
        for (T p : primes) {
            if (p * p > n) break;
            if (n % p == 0) return false;
        }
        return true;
    }

    template <class T>
    std::vector<std::pair<T, int>> factorize(T n) const {
        std::vector<std::pair<T, int>> facts;
        for (T p : primes) {
            if (p * p > n) break;
            if (n % p != 0) continue;
            int exp = 0;
            while (n % p == 0) {
                n /= p;
                ++exp;
            }
            facts.emplace_back(p, exp);
        }
        if (n > 1) {
            facts.emplace_back(n, 1);
        }
        return facts;
    }

    template <class T>
    static std::vector<T> divisors(T n) {
        std::vector<T> ret;
        for (T p = 1; p * p <= n; ++p) {
            if (n % p != 0) continue;
            ret.push_back(p);
            if (n / p == p) continue;
            ret.push_back(n / p);
        }
        return ret;
    }
};

Prime P(10000000);

void solve() {
    int n;
    std::cin >> n;
    if (n < 2) {
        std::cout << 0 << "\n";
        return;
    }

    std::set<int> ps(P.primes.begin(), P.primes.end());
    int ans = 0;
    for (auto p : ps) {
        if (p - 2 > n) break;
        if (ps.count(p - 2)) ++ans;
    }

    std::cout << ans * 2 << "\n";
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    solve();

    return 0;
}
accuracy: 1
time_ms: 150
memory_kb: 38108
final_rank: 16

code_snippet: #include<bits/stdc++.h>
using namespace std;
using UL = unsigned int;
using ULL = unsigned long long;
using LL = long long;
#define rep(i,n) for(int i=0; i<(n); i++)

bool S[10000002]={};

int main() {
 S[0]=S[1]=true;
 for(int i=2; i<3300; i++){
  if(S[i]) continue;
  for(int j=i*i; j<=10000001; j+=i) S[j]=true;
 }

 int N; cin>>N;
 int ans=0;
 for(int i=3; i<=N; i+=2){
  if(!S[i] && !S[i+2]) ans++;
 }
 cout<<ans*2<<endl;

 return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 12896
final_rank: 11

code_snippet: #include"bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,a,b) for(int i=(a);i<(b);i++)
#define all(v) (v).begin(),(v).end()
template<class T>bool chmax(T &a,T b){if(a<b){a=b;return 1;} return 0;}
template<class T>bool chmin(T &a,T b){if(b<a){a=b;return 1;} return 0;}

int dx[4] = {0,0,-1,1};
int dy[4] = {1,-1,0,0};
string rlud = "RLUD";


// run : ctrl + c 
signed main(){

    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(20);

    int n;
    cin>>n;
    if(n<=2){
        cout << 0 << endl;
        return 0;
    }
    int p[n+3]={};
    for(int i=2;i*i<=n+2;i++){
        if(p[i]) continue;
        for(int j=i+i;j<=n+2;j+=i){
            p[j] = 1;
        }
    }
    int ans = 0;
    for(int i=3;i<=n;i++){
        if(p[i]==0 && p[i+2]==0)ans++;
    }
    cout << ans*2 << endl;
    
    
}
accuracy: 1
time_ms: 170
memory_kb: 42288
final_rank: 17

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

struct Prime {
  vector<bool> ch;
  vector<long long> ary;
  Prime(long long N = 20000000) {
    ch.resize(N + 1);
    ch[0] = ch[1] = 1;
    for(int i = 2; i <= N; ++i)
      if(!ch[i]) {
        ary.push_back(i);
        for(int j = 2; (long long)i * j <= N; ++j)
          ch[i * j] = 1;
      }
  }
  inline const bool isprime(int n) { return !ch[n]; }
  inline const long long &operator[](int k) const {
    return (ary[k]);
  }
};

int n;
long long cnt = 0;
Prime p;

int main() {
  int i;
  cin >> n;
  for(i = 2; i <= n; ++i)
    if(p.isprime(i) && p.isprime(2 + i)) cnt += 2;
  cout << cnt << endl;
  return 0;
}
accuracy: 1
time_ms: 110
memory_kb: 21652
final_rank: 12

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

struct Prime {
  vector<bool> ch;
  vector<long long> ary;
  Prime(long long N = 2000000) {
    ch.resize(N + 1);
    ch[0] = ch[1] = 1;
    for(int i = 2; i <= N; ++i)
      if(!ch[i]) {
        ary.push_back(i);
        for(int j = 2; (long long)i * j <= N; ++j)
          ch[i * j] = 1;
      }
  }
  inline const bool isprime(int n) { return !ch[n]; }
  inline const long long &operator[](int k) const {
    return (ary[k]);
  }
};

int n;
long long cnt = 0;
Prime p;

int main() {
  int i;
  cin >> n;
  for(i = 2; i <= n; ++i)
    if(p.isprime(i) && p.isprime(2 + i)) cnt += 2;
  cout << cnt << endl;
  return 0;
}
accuracy: 0.35294117647058826
time_ms: 10
memory_kb: 5000
final_rank: 20

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


vector<bool> hurui(int n){
    vector<bool> A(n + 1, true);
    A[0] = A[1] = false;
    for (int i = 1; i * i <= n; i++){
        if (!A[i])
            continue;
        for (int j = 2 * i; j <= n; j += i)
            A[j] = false;
    }
    return A;
}

signed main(){
    ios::sync_with_stdio(false);
	cin.tie(0);
    cout << fixed << setprecision(20);
    int n;
    cin >> n;
    auto A = hurui(n + 2);
    int ans = 0;
    for (int i = 0; i <= n; i++){
        if (!A[i])
            continue;
        if (A[2 + i])
            ans += 2;
    }
    cout << ans << endl;
}
accuracy: 1
time_ms: 40
memory_kb: 4132
final_rank: 4

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

// 計算量は O(NloglogN) らしい
vector <bool> sieve(int n) { // sieve : ふるい
    vector <bool> is_prime(n + 1, true);
    if (n >= 0) is_prime[0] = false;
    if (n >= 1) is_prime[1] = false;
    for (int i = 2; i * i <= n; i++) {
        if (!is_prime[i]) continue;
        for (int j = 2 * i; j <= n; j += i) {
            is_prime[j] = false;
        }
    }
    return is_prime;
}


// verified
//   http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_1_C&lang=jp
void AOJ_ALDS_1_C() {
    int n;
    cin >> n;
    vector <bool> is_prime = sieve(100000005);
    int ans = 0;
    for (int i = 0; i < n; i++) {
        int m;
        cin >> m;
        ans += is_prime[m];
    }
    cout << ans << "\n";
}


// verified
//   https://onlinejudge.u-aizu.ac.jp/beta/room.html#ACPC2018Day1/problems/C
void ACPC_C() {
    int n;
    cin >> n;
    vector <bool> is_prime = sieve(n+2);
    int ans = 0;
    for (int i = 3; i <= n; i++) {
        ans += is_prime[i] & is_prime[i + 2];
    }
    cout << ans * 2 << "\n";
}

int main() {
    // AOJ_ALDS_1_C();
    ACPC_C();
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 4052
final_rank: 3