stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <vector>

#include <utility>

#define ran(i, s, g) for (i = s; i <= g; i++)

using namespace std;

using ll = long long;

const ll MOD = 1e9 + 7;



int main(void)

{

    int N, W;

    vector<int> w(110);

    vector<int> v(110);

    static int dp[110][100010];

    int i, j, k;

    ll ans = 0;

    ll sum = 0;



    cin >> N >> W;



    ran(i, 1, N)

    {

        cin >> w[i] >> v[i];

        sum += v[i];

    }



    ran(j, 1, sum)

    {

        dp[0][j] = MOD;

    }



    dp[0][0] = 0;



    ran(i, 1, N)

    {

        dp[i][0] = 0;

        ran(j, 1, 100005)

        {

            if (j - v[i] >= 0)

            {

                dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);

            }

            else

            {

                dp[i][j] = dp[i - 1][j];

            }

        }

    }



    for (i = 1; i <= sum; i++)

    {

        if (dp[N][i] <= W)

        {

            ans = max(ans, (ll)i);

        }

    }



    cout << ans << endl;

}

// Faster C++ solution for the same problem (measured speedup: 1.5125681561671234x):
#include <iostream>

#include <algorithm>

#include <vector>

#include <utility>

#define ran(i, s, g) for (i = s; i <= g; i++)

using namespace std;

using ll = long long;

const ll MOD = 1e9 + 7;



int main(void)

{

    int N, W;

    vector<int> w(110);

    vector<int> v(110);

    vector<ll> dp(100010, MOD);

    int i, j, k;

    ll ans = 0;

    ll sum = 0;



    cin >> N >> W;



    ran(i, 1, N)

    {

        cin >> w[i] >> v[i];

        sum += v[i];

    }



    dp[0] = 0;



    for (i = 1; i <= N; i++)

    {

        for (j = sum; j >= v[i]; j--)

        {

            dp[j] = min(dp[j], dp[j - v[i]] + w[i]);

        }

    }



    for (i = 1; i <= sum; i++)

    {

        if (dp[i] <= W)

        {

            ans = max(ans, (ll)i);

        }

    }



    cout << ans << endl;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define VV vector

#define pb push_back

#define bitc  __builtin_popcountl

#define m_p make_pair

#define inf 200000000000000

#define MAXN 1000001

#define eps 0.0000000001

#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);

string char_to_str(char c){string tem(1,c);return tem;}

// string to integer stoi()

// string to long long stoll()

// string.substr(position,length);

// integer to string to_string();



//////////////



#define S second

#define F first

#define int long long  



//////////



int ans[101][100000+1]={};

signed main()

{

    fastio;

    // #ifndef ONLINE_JUDGE

    //     freopen("inputf.in","r",stdin);

    //     freopen("outputf.in","w",stdout);

    // #endif

    int n,W;

    cin>>n>>W;

    for(int i=0;i<=n;++i)

        for(int j=1;j<=100000;++j)

            ans[i][j]=inf;

    for(int i=1;i<=n;++i)

    {

        int w,v;

        cin>>w>>v;

        for(int j=0;j<=100000;++j)

        {

            ans[i][j]=ans[i-1][j];

            if(j-v>=0)

            ans[i][j]=min(ans[i][j],ans[i-1][j-v]+w);

        }

    }

    int an=0;

    for(int i=0;i<=100000;++i){

        if(ans[n][i]<=W)

            an=i;

    }

    cout<<an;

}

// Faster C++ solution for the same problem (measured speedup: 2.7723575223188877x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define VV vector

#define pb push_back

#define bitc  __builtin_popcountl

#define m_p make_pair

#define inf 200000000000000

#define MAXN 1000001

#define eps 0.0000000001

#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);

string char_to_str(char c){string tem(1,c);return tem;}

// string to integer stoi()

// string to long long stoll()

// string.substr(position,length);

// integer to string to_string();



//////////////



#define S second

#define F first

#define int long long  



///////////// 



signed main()

{

	fastio;

	#ifdef ANIKET_GOYAL

		freopen("inputf.in","r",stdin);

		freopen("outputf.in","w",stdout);

	#endif

	int n,w;

	cin>>n>>w;

	int v[100001]={};

	for(int i=0;i<=100000;++i)

		v[i]=inf;

	v[0]=0;

	for(int i=0;i<n;++i)

	{

		int we,ha;

		cin>>we>>ha;

		for(int j=100000;j-ha>=0;--j)

		{

			v[j]=min(v[j],v[j-ha]+we);

		}

	}

	int ans=0;

	for(int i=0;i<=100000;++i)

	{

		if(v[i]<=w)

			ans=i;

	}

	cout<<ans;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

const long long mod=1e11+7;

long long dp[103][100004];



int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    int n,w;

    cin>>n>>w;

    int a[103],b[103];

    for(int i=0;i<n;i++)cin>>a[i]>>b[i];

    for(int i=0;i<n+1;i++)for(int j=0;j<100004;j++)dp[i][j]=mod;

    dp[0][0]=0;

    for(int i=0;i<n;i++)for(int j=0;j<100004;j++){

        if(j>=b[i])dp[i+1][j]=min(dp[i][j],dp[i][j-b[i]]+a[i]);

        else dp[i+1][j]=dp[i][j];

    }

    

    long long res=0;

    for(int j=0;j<100004;j++)if(dp[n][j]<=w)res=j;

    cout<<res<<endl;

    

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.771141867687591x):
#include<bits/stdc++.h>

using namespace std;

const int mod=1e9+7;



int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    int n,w;

    cin>>n>>w;

    int a[103],b[103];

    int dp[2][100004];

    for(int i=0;i<n;i++)cin>>a[i]>>b[i];

    for(int i=0;i<2;i++)for(int j=0;j<100004;j++)dp[i][j]=mod;

    dp[0][0]=0;

    for(int i=0;i<n;i++)for(int j=0;j<100004;j++){

        if(j>=b[i])dp[(i+1)&1][j]=min(dp[i&1][j],dp[i&1][j-b[i]]+a[i]);

        else dp[(i+1)&1][j]=dp[i&1][j];

    }

    

    int res=0;

    for(int j=0;j<100004;j++)if(dp[n&1][j]<=w)res=j;

    cout<<res<<endl;

    

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define ll long long

using namespace std;

const int maxn = 2e5+5;

inline void fastio() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}



int _;



int main()

{

    //fastio();

    double r;

    scanf("%lf",&r);

    printf("%.8f\n",r*2*acos(-1));

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.002937188701215x):
#include<cstdio>

#include<cmath>

#define ll long long

using namespace std;

const int maxn = 2e5+5;



int _;



int main()

{

  //fastio();

  double r;

  scanf("%lf",&r);

  printf("%.8f\n",(double)r*2*acos(-1));

  return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

#define ll long long

using namespace std;

const int maxn = 2e5+5;

//inline void fastio() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}



int _;



int main()

{

  //fastio();

  double r;

  scanf("%lf",&r);

  printf("%.8f\n",r*2*acos(-1));

  return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.002937188701215x):
#include<cstdio>

#include<cmath>

#define ll long long

using namespace std;

const int maxn = 2e5+5;



int _;



int main()

{

  //fastio();

  double r;

  scanf("%lf",&r);

  printf("%.8f\n",(double)r*2*acos(-1));

  return 0;

}
// Slower C++ solution:
#include<iostream>

#include<string.h>

# define P 3.141592653

#include <iomanip>



using namespace std;

int main()

{

	int r;

	double s;

	while(cin>>r)

	{

		s=2*P*r;

		printf("%.10lf\n",s);

	}

	return 0;

} 

// Faster C++ solution for the same problem (measured speedup: 5.129410797673039x):
#include<cstdio>

#include<cmath>

#define pi acos(-1)

using namespace std;



int main()

{

    int r;

    double area;

    scanf("%d", &r);

    printf("%lf", 2*pi*r);

    return 0;

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



int main(void) {

	int r;

	cin >> r;

	printf("%lf\n", (double)(2 * r)*M_PI);

}

// Faster C++ solution for the same problem (measured speedup: 5.033761446392438x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	double r;

	scanf("%lf", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



int main(void) {

	double r;

	scanf("%lf", &r);

	printf("%lf\n", 2 * r*M_PI);

}

// Faster C++ solution for the same problem (measured speedup: 5.00527319654805x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	double r;

	scanf("%lf", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



int main(void) {

	int r;

	cin >> r;

	printf("%lf\n", (double)(2 * r)*M_PI);

}

// Faster C++ solution for the same problem (measured speedup: 5.116079555983949x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



int main(void) {

	double r;

	scanf("%lf", &r);

	printf("%lf\n", 2 * r*M_PI);

}

// Faster C++ solution for the same problem (measured speedup: 5.087125432081416x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}

// Faster C++ solution for the same problem (measured speedup: 5.073759206696827x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



int main(void) {

	int r;

	cin >> r;

	printf("%lf\n", (double)(2 * r)*M_PI);

}

// Faster C++ solution for the same problem (measured speedup: 5.116079555983949x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = 3.14159265358979;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



int main(void) {

	double r;

	scanf("%lf", &r);

	printf("%lf\n", 2 * r*M_PI);

}

// Faster C++ solution for the same problem (measured speedup: 5.087125432081416x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = 3.14159265358979;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#define _USE_MATH_DEFINES

#include<iostream>

#include<string>

#include<vector>

#include<algorithm>

#include<cmath>

#include<cstdio>



using namespace std;



double pi = M_PI;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}

// Faster C++ solution for the same problem (measured speedup: 5.073759206696827x):
#include<cmath>

#include<cstdio>



using namespace std;



double pi = 3.14159265358979;



int main(void) {

	int r;

	scanf("%d", &r);

	printf("%lf\n", 2 * pi * r);

}
// Slower C++ solution:
#include<iostream>

using namespace std;

int main()

{double a,x,p;

p=3.14159265358979323846;

scanf("%lf",&a);

x=2*a*p;

printf("%.20lf",x);}


// Faster C++ solution for the same problem (measured speedup: 5.02123925274083x):
#include<stdio.h>



#include<math.h>





int main()

{

     double x;

    scanf("%lf",&x);

    printf("%lf",2*3.141592*x);

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

  int x;

  cin>>x;

  return cout<<fixed<<setprecision(15)<<2*M_PI*x<<endl,0;

}

// Faster C++ solution for the same problem (measured speedup: 5.157866167895875x):
#include<stdio.h>

#include<math.h>

int main(){int x;while(scanf("%d",&x)!=0)return printf("%.15lf",2*M_PI*x),0;}
// Slower C++ solution:
///HELLO THERE~!

///CREATED BY MD SADMAN MEHEDI SIVAN(IUT CSE-SWE^19)



#include <bits/stdc++.h>



#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define read freopen("blue.txt","r",stdin);

#define write freopen("red.txt","w",stdout);





typedef long long ll;



using namespace std;





int main()



{



    fastio;

    double pie=2*acos(0.0);



    double a;

    cin>>a;

    double result=2.0*pie*a;



    cout<<fixed<<setprecision(22)<<result;





    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.195731404980847x):
#include<cstdio>



using namespace std;



const double P = 3.14159265;



int main()

{

    double a;

    while(scanf("%lf", &a) != EOF) {

        printf("%f\n", a*P*2.0);

    }

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>



using namespace std;

int main()

{

    ios_base::sync_with_stdio(false);

    long double r,s;

    cin>>r;

    s=2*3.141592653589*r;

    printf("%.12Lf",s);





    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.151987364401112x):
#include<cstdio>



using namespace std;



const double P = 3.14159265;



int main()

{

    double a;

    while(scanf("%lf", &a) != EOF) {

        printf("%f\n", a*P*2.0);

    }

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main()

{

    

    

    

    int R;

    double pi=3.14159265358979323846,c;

    cin>>R;

    c=2*pi*R;

    printf("%0.20lf",c);

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.122271312792018x):
#include <stdio.h>

#define k 6.28318530717958623200

int main()

{

    int r;

    double c;

    scanf("%d",&r);

    printf("%lf\n",r*k);



    return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",2*n*acos(-1.0)); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.056239285726752x):
#include<cstdio>

using namespace std;



int main() {

	int n; scanf("%d",&n);

	printf("%.5lf\n",n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",(double)2*n*acos(-1.0)); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.056249827194726x):
#include<cstdio>

using namespace std;



int main() {

	int n; scanf("%d",&n);

	printf("%.5lf\n",n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",n*6.28318530717958623200); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.0562483865736105x):
#include<cstdio>

using namespace std;



int main() {

	int n; scanf("%d",&n);

	printf("%.5lf\n",n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",2*n*acos(-1.0)); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.055699127507623x):
#include<cstdio>

using namespace std;



int main() {

	int n; scanf("%d",&n);

	printf("%.5Lf\n",(long double)n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",(double)2*n*acos(-1.0)); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.0557096678494515x):
#include<cstdio>

using namespace std;



int main() {

	int n; scanf("%d",&n);

	printf("%.5Lf\n",(long double)n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",n*6.28318530717958623200); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 5.055708227382238x):
#include<cstdio>

using namespace std;



int main() {

	int n; scanf("%d",&n);

	printf("%.5Lf\n",(long double)n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",2*n*acos(-1.0)); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 4.9852703084619945x):
#include<cstdio>

using namespace std;



int main() {

	double n; scanf("%lf",&n);

	printf("%.5lf",n*6.28318530717958623200); 

	return 0;

}
// Slower C++ solution:
#include<map>

#include<set>

#include<queue>

#include<cmath>

#include<cstdio>

#include<vector>

#include<string>

#include<cstring>

#include<iostream>

#include<algorithm>

#define lc (x<<1)

#define rc (x<<1|1)

#define gc getchar()//(p1==p2&&(p2=(p1=buf)+fread(buf,1,size,stdin),p1==p2)?EOF:*p1++)

#define mk make_pair

#define pi pair<int,int>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

const int N=2e5+10,size=1<<20;



//char buf[size],*p1=buf,*p2=buf;

template<class o> void qr(o &x) {

	char c=gc; x=0; int f=1;

	while(!isdigit(c)){if(c=='-')f=-1; c=gc;}

	while(isdigit(c)) x=x*10+c-'0',c=gc;

	x*=f;

}

template<class o> void qw(o x) {

	if(x/10) qw(x/10);

	putchar(x%10+'0');

}

template<class o> void pr1(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); putchar(' ');

}

template<class o> void pr2(o x) {

	if(x<0)x=-x,putchar('-');

	qw(x); puts("");

}



int main() {

	int n; qr(n);

	printf("%.7lf\n",(double)2*n*acos(-1.0)); 

	return 0;

}




// Faster C++ solution for the same problem (measured speedup: 4.985280701970753x):
#include<cstdio>

using namespace std;



int main() {

	double n; scanf("%lf",&n);

	printf("%.5lf",n*6.28318530717958623200); 

	return 0;

}