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

#include <algorithm>

#include <vector>

#define fs first

#define sc second

using namespace std;

const int maxn = 1e5+10;

using pii = pair<int,int>;



int N;

int main(){

    cin>>N;

    cout<<(N+2-1)/2<<endl;





    return 0;

}

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



int main() {

    int a;

    scanf("%d", &a);

    int b =(a%2==0) ? (a/2) : ((a/2)+1);

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

    

    return 0;

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

using namespace std;

main()

{



int n;

cin>>n;

if(n%2==0)

{

    cout<<""<<n/2;

}

else

{

    cout<<""<<(n/2)+1;

}



}


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



int main() {

    int a;

    scanf("%d", &a);

    int b =(a%2==0) ? (a/2) : ((a/2)+1);

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

    

    return 0;

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

#include <algorithm>

#include <vector>

#define fs first

#define sc second

using namespace std;

const int maxn = 1e5+10;

using pii = pair<int,int>;



int N;

int main(){

    cin>>N;

    cout<<(N+2-1)/2<<endl;





    return 0;

}

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

int main()

{

	int N;

	int X;

	scanf("%d",&N);

	X= N/2;

	if(N%2==0)

	{

		printf("%d",X);

	}

	else if(N%2!=0)

	{

		printf("%d",++X);

	}

	



	

	return 0;

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

using namespace std;

main()

{



int n;

cin>>n;

if(n%2==0)

{

    cout<<""<<n/2;

}

else

{

    cout<<""<<(n/2)+1;

}



}


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

int main()

{

	int N;

	int X;

	scanf("%d",&N);

	X= N/2;

	if(N%2==0)

	{

		printf("%d",X);

	}

	else if(N%2!=0)

	{

		printf("%d",++X);

	}

	



	

	return 0;

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

#include <algorithm>

#include <vector>

#define fs first

#define sc second

using namespace std;

const int maxn = 1e5+10;

using pii = pair<int,int>;



int N;

int main(){

    cin>>N;

    cout<<(N+2-1)/2<<endl;





    return 0;

}

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



int main (){

	

	int n,i;

	

	scanf("%d",&n);

	

	if(n%2==0){

		printf("%d\n",n/2);

	}else{

		printf("%d\n",(n/2)+1);

	}

return 0;

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

using namespace std;

main()

{



int n;

cin>>n;

if(n%2==0)

{

    cout<<""<<n/2;

}

else

{

    cout<<""<<(n/2)+1;

}



}


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



int main (){

	

	int n,i;

	

	scanf("%d",&n);

	

	if(n%2==0){

		printf("%d\n",n/2);

	}else{

		printf("%d\n",(n/2)+1);

	}

return 0;

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

#include <algorithm>

#include <vector>

#define fs first

#define sc second

using namespace std;

const int maxn = 1e5+10;

using pii = pair<int,int>;



int N;

int main(){

    cin>>N;

    cout<<(N+2-1)/2<<endl;





    return 0;

}

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



int main() {

	int A;

	int B = 2; 

	scanf("%d", &A);

	

	if(A % B == 0) {

	printf("%d\n", A/B);

	}

	

	else

	printf("%d\n", (A/B)+1);

	

	return 0;

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

using namespace std;

main()

{



int n;

cin>>n;

if(n%2==0)

{

    cout<<""<<n/2;

}

else

{

    cout<<""<<(n/2)+1;

}



}


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



int main() {

	int A;

	int B = 2; 

	scanf("%d", &A);

	

	if(A % B == 0) {

	printf("%d\n", A/B);

	}

	

	else

	printf("%d\n", (A/B)+1);

	

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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

int main(){

	int a;

	scanf("%d", &a);

	(a%2 == 0)? printf("%d", a/2) : printf("%d", a/2 + 1);

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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

int main(){

	int a;

	scanf("%d", &a);

	(a%2 == 0)? printf("%d", a/2) : printf("%d", a/2 + 1);

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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

int main(){

	int a;

	scanf("%d", &a);

	(a%2 == 0)? printf("%d", a/2) : printf("%d", a/2 + 1);

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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

int main(){

	int a;

	scanf("%d", &a);

	(a%2 == 0)? printf("%d", a/2) : printf("%d", a/2 + 1);

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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

int main(){

	int a;

	scanf("%d", &a);

	(a%2 == 0)? printf("%d", a/2) : printf("%d", a/2 + 1);

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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



int main()



{

	int n;

	scanf("%d", &n);

	

	if(n % 2 == 0)

	{

		printf("%d", n/2);

	}

	else if(n % 2 != 0)

	{

		printf("%d", n/2 +1);

	}

	 return 0;



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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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



int main()



{

	int n;

	scanf("%d", &n);

	

	if(n % 2 == 0)

	{

		printf("%d", n/2);

	}

	else if(n % 2 != 0)

	{

		printf("%d", n/2 +1);

	}

	 return 0;



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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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



int main()



{

	int n;

	scanf("%d", &n);

	

	if(n % 2 == 0)

	{

		printf("%d", n/2);

	}

	else if(n % 2 != 0)

	{

		printf("%d", n/2 +1);

	}

	 return 0;



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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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



int main()



{

	int n;

	scanf("%d", &n);

	

	if(n % 2 == 0)

	{

		printf("%d", n/2);

	}

	else if(n % 2 != 0)

	{

		printf("%d", n/2 +1);

	}

	 return 0;



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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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



int main()



{

	int n;

	scanf("%d", &n);

	

	if(n % 2 == 0)

	{

		printf("%d", n/2);

	}

	else if(n % 2 != 0)

	{

		printf("%d", n/2 +1);

	}

	 return 0;



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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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



int main(){

 int N;

 scanf("%d", &N);

 

 if(N%2==0){

  printf("%d", N/2);

 }else{

  printf("%d",N/2+1);

 }

 return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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



int main(){

 int N;

 scanf("%d", &N);

 

 if(N%2==0){

  printf("%d", N/2);

 }else{

  printf("%d",N/2+1);

 }

 return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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



int main(){

 int N;

 scanf("%d", &N);

 

 if(N%2==0){

  printf("%d", N/2);

 }else{

  printf("%d",N/2+1);

 }

 return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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



int main(){

 int N;

 scanf("%d", &N);

 

 if(N%2==0){

  printf("%d", N/2);

 }else{

  printf("%d",N/2+1);

 }

 return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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



int main(){

 int N;

 scanf("%d", &N);

 

 if(N%2==0){

  printf("%d", N/2);

 }else{

  printf("%d",N/2+1);

 }

 return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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

int main(){

	int N;

	int x=2;

		scanf("%d",&N);

			if(N%x==0){

				printf("%d\n",N/2);

			}

	        else{

	        	printf("%d\n",(N/2)+1);

			}

	

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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

int main(){

	int N;

	int x=2;

		scanf("%d",&N);

			if(N%x==0){

				printf("%d\n",N/2);

			}

	        else{

	        	printf("%d\n",(N/2)+1);

			}

	

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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

int main(){

	int N;

	int x=2;

		scanf("%d",&N);

			if(N%x==0){

				printf("%d\n",N/2);

			}

	        else{

	        	printf("%d\n",(N/2)+1);

			}

	

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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

int main(){

	int N;

	int x=2;

		scanf("%d",&N);

			if(N%x==0){

				printf("%d\n",N/2);

			}

	        else{

	        	printf("%d\n",(N/2)+1);

			}

	

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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

int main(){

	int N;

	int x=2;

		scanf("%d",&N);

			if(N%x==0){

				printf("%d\n",N/2);

			}

	        else{

	        	printf("%d\n",(N/2)+1);

			}

	

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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

int main()



{

	int N;

	scanf("%d",&N);

	int sheet = (N % 2 ==0)? (N / 2) : (N / 2 + 1);

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

	

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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

int main()



{

	int N;

	scanf("%d",&N);

	int sheet = (N % 2 ==0)? (N / 2) : (N / 2 + 1);

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

	

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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

int main()



{

	int N;

	scanf("%d",&N);

	int sheet = (N % 2 ==0)? (N / 2) : (N / 2 + 1);

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

	

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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

int main()



{

	int N;

	scanf("%d",&N);

	int sheet = (N % 2 ==0)? (N / 2) : (N / 2 + 1);

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

	

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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

int main()



{

	int N;

	scanf("%d",&N);

	int sheet = (N % 2 ==0)? (N / 2) : (N / 2 + 1);

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

	

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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

int main(){

	int n;

	scanf("%d", &n);

	if (n%2==1){

		printf("%d", n/2+1);

	}

	else if(n%2==0){

		printf("%d", n/2);

	}

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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

int main(){

	int n;

	scanf("%d", &n);

	if (n%2==1){

		printf("%d", n/2+1);

	}

	else if(n%2==0){

		printf("%d", n/2);

	}

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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

int main(){

	int n;

	scanf("%d", &n);

	if (n%2==1){

		printf("%d", n/2+1);

	}

	else if(n%2==0){

		printf("%d", n/2);

	}

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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

int main(){

	int n;

	scanf("%d", &n);

	if (n%2==1){

		printf("%d", n/2+1);

	}

	else if(n%2==0){

		printf("%d", n/2);

	}

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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

int main(){

	int n;

	scanf("%d", &n);

	if (n%2==1){

		printf("%d", n/2+1);

	}

	else if(n%2==0){

		printf("%d", n/2);

	}

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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

int main()

{

	int N; 

	int O; 

	int Z;

	scanf("%d",&N);

	if(N%2!=0){

		printf("%d",N/2+1);

	}

	else if(N%2==0)

		printf("%d",N/2);

	

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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

int main()

{

	int N; 

	int O; 

	int Z;

	scanf("%d",&N);

	if(N%2!=0){

		printf("%d",N/2+1);

	}

	else if(N%2==0)

		printf("%d",N/2);

	

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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

int main()

{

	int N; 

	int O; 

	int Z;

	scanf("%d",&N);

	if(N%2!=0){

		printf("%d",N/2+1);

	}

	else if(N%2==0)

		printf("%d",N/2);

	

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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

int main()

{

	int N; 

	int O; 

	int Z;

	scanf("%d",&N);

	if(N%2!=0){

		printf("%d",N/2+1);

	}

	else if(N%2==0)

		printf("%d",N/2);

	

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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

int main()

{

	int N; 

	int O; 

	int Z;

	scanf("%d",&N);

	if(N%2!=0){

		printf("%d",N/2+1);

	}

	else if(N%2==0)

		printf("%d",N/2);

	

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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



int main(){

	int N,i;

	scanf("%d",&N);

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

		N--;

	}

	printf("%d",N);

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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



int main(){

	int N,i;

	scanf("%d",&N);

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

		N--;

	}

	printf("%d",N);

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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



int main(){

	int N,i;

	scanf("%d",&N);

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

		N--;

	}

	printf("%d",N);

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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



int main(){

	int N,i;

	scanf("%d",&N);

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

		N--;

	}

	printf("%d",N);

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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



int main(){

	int N,i;

	scanf("%d",&N);

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

		N--;

	}

	printf("%d",N);

	return 0;

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

using namespace std;



int main()

{

    int n; cin>> n;

    cout<< (n + 1) / 2;

    return 0;

}


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



int main ()

{

	int N;

	scanf("%d", &N);

	

	(N%2 == 0) ? printf("%d", (N/2)) : printf("%d", (N/2)+1);

	

	

	return 0;

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

using namespace std ;



int main(){

	long long a;

	cin>>a;

	cout<<(a+1)/2<<endl;

}

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



int main ()

{

	int N;

	scanf("%d", &N);

	

	(N%2 == 0) ? printf("%d", (N/2)) : printf("%d", (N/2)+1);

	

	

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	   n/=2;

	else

	   n=n/2+1;

	cout<<n<<endl;

	return 0;

}

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



int main ()

{

	int N;

	scanf("%d", &N);

	

	(N%2 == 0) ? printf("%d", (N/2)) : printf("%d", (N/2)+1);

	

	

	return 0;

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

using namespace std;

int main(){

	int n;

	cin>>n;

	int m=(n+1)/2;

	cout<<m<<endl;

    return 0; 

}

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



int main ()

{

	int N;

	scanf("%d", &N);

	

	(N%2 == 0) ? printf("%d", (N/2)) : printf("%d", (N/2)+1);

	

	

	return 0;

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



using namespace std;



#define ll long long

const int N = 300005;



int n;



int main()

{



cin >> n ;

cout << n/2 + n%2;

    return 0;

}


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



int main ()

{

	int N;

	scanf("%d", &N);

	

	(N%2 == 0) ? printf("%d", (N/2)) : printf("%d", (N/2)+1);

	

	

	return 0;

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

 using namespace std;

int main ()

{

int num ,re;

cin >>num;

if ( num%2==0)

{

re =num/2;

}

else {

	re =num/2;

	re+=1;

}



cout <<re ;

system("pause");

}


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

int main()

{

	int N,a;

	scanf("%d",&N);

	a=N/2+1;

	if(N%2==0)

	{

		printf("%d",N/2);

	}

	else

	{

		printf("%d",a);

	}

	return 0;

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

using namespace std;



int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int t;

    cin >> t;

    cout << (t + 1) / 2 << endl;

}


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

int main()

{

	int N,a;

	scanf("%d",&N);

	a=N/2+1;

	if(N%2==0)

	{

		printf("%d",N/2);

	}

	else

	{

		printf("%d",a);

	}

	return 0;

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

 using namespace std;

int main ()

{

int num ,re;

cin >>num;

if ( num%2==0)

{

re =num/2;

}

else {

	re =num/2;

	re+=1;

}



cout <<re ;

system("pause");

}


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

int main ()

{

	int n;

	scanf("%d", &n);

	(n%2==0) ? (printf("%d", n/2)) : (printf("%d", (n/2)+1));

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

using namespace std;



int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int t;

    cin >> t;

    cout << (t + 1) / 2 << endl;

}


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

int main ()

{

	int n;

	scanf("%d", &n);

	(n%2==0) ? (printf("%d", n/2)) : (printf("%d", (n/2)+1));

}