stablegradients/pie-gem5-pairs huggingface dataset:
// 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.273291256252968x):
#include <stdio.h>



int main (){

	

	int n,z;

	scanf ("%d", &n);

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

	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.337953658092406x):
#include <stdio.h>



int main (){

	

	int n,z;

	scanf ("%d", &n);

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

	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 a;

	scanf("%d",&a);

if(a%2==0){

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

}

else{

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

}

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.346858890106502x):
#include<stdio.h>

int main(){

	int a;

	scanf("%d",&a);

if(a%2==0){

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

}

else{

	printf("%d",a/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.282213829398635x):
#include <stdio.h>



int main(){

	int a,b;

	

	scanf("%d", &a);

	b = a/2;

	

	if(a%2==1){

		printf("%d", b+1);

	}else{

		printf("%d", b);

	}

	

}
// 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.346985642037164x):
#include <stdio.h>



int main(){

	int a,b;

	

	scanf("%d", &a);

	b = a/2;

	

	if(a%2==1){

		printf("%d", b+1);

	}else{

		printf("%d", b);

	}

	

}
// 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.280980218468522x):
#include<stdio.h>



int main(){

	

	int N;

	scanf("%d",&N);

	int x;

	x = N + 1;

	

	if(N%2 == 0){

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

	}

	else{

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

	}

	

	

	

	

	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.345736904264667x):
#include<stdio.h>



int main(){

	

	int N;

	scanf("%d",&N);

	int x;

	x = N + 1;

	

	if(N%2 == 0){

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

	}

	else{

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

	}

	

	

	

	

	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.282116579905261x):
#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()

{

    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.346887200046446x):
#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;

    while(cin>>n)

        cout<<n/2+n%2<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.278085584090248x):
#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>



int main()

{

	int n;

	std::cin >> n;

	if (n % 2 != 0)

		++n;

	std::cout << n / 2 << '\n';

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.2704461890974095x):
#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)

	 cout<<n/2<<endl;

	else

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.27377720896816x):
#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;

    while(cin>>n)

        cout<<n/2+n%2<<endl;

    return 0;

}


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

int main()

{

	int A;

	scanf("%d", &A);

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

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

	return 0;

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



int main()

{

	int n;

	std::cin >> n;

	if (n % 2 != 0)

		++n;

	std::cout << n / 2 << '\n';

	return 0;

}

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

int main()

{

	int A;

	scanf("%d", &A);

	int sheet = (A % 2 == 0) ? (A/2) : (A/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)

	 cout<<n/2<<endl;

	else

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

	return 0;

}

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

int main()

{

	int A;

	scanf("%d", &A);

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

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

	return 0;

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

using namespace std;

int main()

{

    int n;

    while(cin>>n)

        cout<<n/2+n%2<<endl;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.277773012269994x):
#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>



int main()

{

	int n;

	std::cin >> n;

	if (n % 2 != 0)

		++n;

	std::cout << n / 2 << '\n';

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.270134069687326x):
#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)

	 cout<<n/2<<endl;

	else

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

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.273464892292813x):
#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;

    while(cin>>n)

        cout<<n/2+n%2<<endl;

    return 0;

}


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



int main (){

	

	int n,z;

	scanf ("%d", &n);

	if (n%2 != 0){

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

	}

	else {

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

	}

	return 0;

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



int main()

{

	int n;

	std::cin >> n;

	if (n % 2 != 0)

		++n;

	std::cout << n / 2 << '\n';

	return 0;

}

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



int main (){

	

	int n,z;

	scanf ("%d", &n);

	if (n%2 != 0){

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

	}

	else {

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

	}

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	 cout<<n/2<<endl;

	else

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

	return 0;

}

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



int main (){

	

	int n,z;

	scanf ("%d", &n);

	if (n%2 != 0){

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

	}

	else {

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

	}

	return 0;

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

using namespace std;

int main()

{

    int n;

    while(cin>>n)

        cout<<n/2+n%2<<endl;

    return 0;

}


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

int main(){

	 int a;

	  

	scanf("%d",&a);

	

	  if(a % 2 == 0){

			

		a /=2;  	

			printf("%d",a);   	

	  } 

	  else{

	  	

	  	a /=2;

	  		printf("%d",a+1);

	  }

	

	return 0;

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



int main()

{

	int n;

	std::cin >> n;

	if (n % 2 != 0)

		++n;

	std::cout << n / 2 << '\n';

	return 0;

}

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

int main(){

	 int a;

	  

	scanf("%d",&a);

	

	  if(a % 2 == 0){

			

		a /=2;  	

			printf("%d",a);   	

	  } 

	  else{

	  	

	  	a /=2;

	  		printf("%d",a+1);

	  }

	

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	 cout<<n/2<<endl;

	else

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

	return 0;

}

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

int main(){

	 int a;

	  

	scanf("%d",&a);

	

	  if(a % 2 == 0){

			

		a /=2;  	

			printf("%d",a);   	

	  } 

	  else{

	  	

	  	a /=2;

	  		printf("%d",a+1);

	  }

	

	return 0;

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

using namespace std;

int main()

{

    int n;

    while(cin>>n)

        cout<<n/2+n%2<<endl;

    return 0;

}


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

int main()

{

	int N;

  int hasil;

	scanf("%d", &N);



	if(N%2!=0){

    hasil=N/2;

		printf("%d", hasil+1);

	}

  else{

    hasil=N/2;

    printf("%d", hasil);

  }

	return 0;

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



int main()

{

	int n;

	std::cin >> n;

	if (n % 2 != 0)

		++n;

	std::cout << n / 2 << '\n';

	return 0;

}

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

int main()

{

	int N;

  int hasil;

	scanf("%d", &N);



	if(N%2!=0){

    hasil=N/2;

		printf("%d", hasil+1);

	}

  else{

    hasil=N/2;

    printf("%d", hasil);

  }

	return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	if(n%2==0)

	 cout<<n/2<<endl;

	else

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

	return 0;

}

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

int main()

{

	int N;

  int hasil;

	scanf("%d", &N);



	if(N%2!=0){

    hasil=N/2;

		printf("%d", hasil+1);

	}

  else{

    hasil=N/2;

    printf("%d", hasil);

  }

	return 0;

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

using namespace std;

/*

#define mod 7

typedef long long ll;



ll fact[1000006], inv[1000006];



ll fp(ll base, ll exp)

{

    if (exp == 0)

        return 1;

    ll ans = fp(base, exp / 2);

    ans = (ans * ans) % mod;

    if (exp % 2 != 0)

        ans = (ans * (base % mod)) % mod;

    return ans;

}



void calcFacAndInv(ll n)

{

    fact[0] = inv[0] = 1;

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

    {

        fact[i] = (i * fact[i - 1]) % mod;

        inv[i] = fp(fact[i], mod - 2);

    }

}



ll ncr(ll n, ll r)

{

    return ((fact[n] * inv[r]) % mod * inv[n - r]) % mod;

}



ll npr(ll n, ll r)

{

    return (fact[n] * inv[n - r]) % mod;

}



int main()

{

    calcFacAndInv(100000);

     cout<<inv[3];

    return 0;

}

*/





// GCD



int gcd(long long a,long long b)

{

    if (b==0)

        return a;

    return gcd (b,a%b);

}

//fast power

/*

#define mod 1000000007

long long fp(long long  base, long long exp)

{

    if (exp == 0)

        return 1;

    long long  ans = fp(base, exp / 2);

    ans = (ans * ans);

    if (exp % 2 != 0)

        ans = (ans * (base )) ;

    return ans;

}

*/

//prime factoriation

/*

set<int >s;

bool prime factorization (int x)

{

    for (int j=2; j*j<=x; ++j)

    {

        while (x%j==0)

        {

            s.insert(j);

            x/=j;

        }

    }

    if (x>1)

    {

        s.insert(x);

    }

    if (s.size()==2)

        return true ;

    else

        return false ;

}



#define ll long long

int a,b,q,p,n;

int countDivisorss(int x,int y)

{

    ll cnt = 0;

    for (int i = min(x,y); i <= sqrt(n); i++)

    {

        if (x % i == 0&&y%i==0)

        {

            if (x / i == i||y / i == i)

                cnt++;



            else

                cnt = cnt + 2;

        }

    }

    return cnt;

}

int countDivisors(int x)

{

    ll cnt = 0;

    int tmp=n;

    if (n-x>10000000)  tmp=sqrt(n);

    for (int i = x; i <= tmp; i++)

    {

        if (x % i == 0)

        {

         if (x/i==i)

            cnt++;

         else

            cnt = cnt + 2;

        }

    }

    return cnt;

}

*/



/*

        int s =n/2,e=n-1;

        while (s<=e&&e<=n-1)

        {

            int mid =s+e/2;



            if (arr[mid]==arr[n/2])

            {

                s=mid;

                num +=mid -s;

            }

            else

                e=mid-1;

        }

        */









const int N = 1e5 + 5;



vector<int> adj[N];

bool visited[N];

int nodesNum;

void dfs(int node)

{

   if (visited[node])

       return;

   visited[node] = true;

   for (int child: adj[node])

       dfs(child);

}



int main()

{

   int n;

   cin>>n;

   if (n%2==0)

    cout<<n/2;

   else 

    cout<<n/2+1;

   return 0;

}






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

#define ll long long

using namespace std;



int main()

{ ll n;

cin>>n;

if(n%2==0)

    cout << n/2;

else

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

    return 0;

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

using namespace std;

/*

#define mod 7

typedef long long ll;



ll fact[1000006], inv[1000006];



ll fp(ll base, ll exp)

{

    if (exp == 0)

        return 1;

    ll ans = fp(base, exp / 2);

    ans = (ans * ans) % mod;

    if (exp % 2 != 0)

        ans = (ans * (base % mod)) % mod;

    return ans;

}



void calcFacAndInv(ll n)

{

    fact[0] = inv[0] = 1;

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

    {

        fact[i] = (i * fact[i - 1]) % mod;

        inv[i] = fp(fact[i], mod - 2);

    }

}



ll ncr(ll n, ll r)

{

    return ((fact[n] * inv[r]) % mod * inv[n - r]) % mod;

}



ll npr(ll n, ll r)

{

    return (fact[n] * inv[n - r]) % mod;

}



int main()

{

    calcFacAndInv(100000);

     cout<<inv[3];

    return 0;

}

*/





// GCD



int gcd(long long a,long long b)

{

    if (b==0)

        return a;

    return gcd (b,a%b);

}

//fast power

/*

#define mod 1000000007

long long fp(long long  base, long long exp)

{

    if (exp == 0)

        return 1;

    long long  ans = fp(base, exp / 2);

    ans = (ans * ans);

    if (exp % 2 != 0)

        ans = (ans * (base )) ;

    return ans;

}

*/

//prime factoriation

/*

set<int >s;

bool prime factorization (int x)

{

    for (int j=2; j*j<=x; ++j)

    {

        while (x%j==0)

        {

            s.insert(j);

            x/=j;

        }

    }

    if (x>1)

    {

        s.insert(x);

    }

    if (s.size()==2)

        return true ;

    else

        return false ;

}



#define ll long long

int a,b,q,p,n;

int countDivisorss(int x,int y)

{

    ll cnt = 0;

    for (int i = min(x,y); i <= sqrt(n); i++)

    {

        if (x % i == 0&&y%i==0)

        {

            if (x / i == i||y / i == i)

                cnt++;



            else

                cnt = cnt + 2;

        }

    }

    return cnt;

}

int countDivisors(int x)

{

    ll cnt = 0;

    int tmp=n;

    if (n-x>10000000)  tmp=sqrt(n);

    for (int i = x; i <= tmp; i++)

    {

        if (x % i == 0)

        {

         if (x/i==i)

            cnt++;

         else

            cnt = cnt + 2;

        }

    }

    return cnt;

}

*/



/*

        int s =n/2,e=n-1;

        while (s<=e&&e<=n-1)

        {

            int mid =s+e/2;



            if (arr[mid]==arr[n/2])

            {

                s=mid;

                num +=mid -s;

            }

            else

                e=mid-1;

        }

        */









const int N = 1e5 + 5;



vector<int> adj[N];

bool visited[N];

int nodesNum;

void dfs(int node)

{

   if (visited[node])

       return;

   visited[node] = true;

   for (int child: adj[node])

       dfs(child);

}



int main()

{

   int n;

   cin>>n;

   if (n%2==0)

    cout<<n/2;

   else 

    cout<<n/2+1;

   return 0;

}






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

using namespace std;

int main()

{

    int n;

    cin>>n;

    if(n%2==0){

        cout<<n/2;

    }

    else{

        cout<<n/2+1;

    }

    return 0;

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

using namespace std;

/*

#define mod 7

typedef long long ll;



ll fact[1000006], inv[1000006];



ll fp(ll base, ll exp)

{

    if (exp == 0)

        return 1;

    ll ans = fp(base, exp / 2);

    ans = (ans * ans) % mod;

    if (exp % 2 != 0)

        ans = (ans * (base % mod)) % mod;

    return ans;

}



void calcFacAndInv(ll n)

{

    fact[0] = inv[0] = 1;

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

    {

        fact[i] = (i * fact[i - 1]) % mod;

        inv[i] = fp(fact[i], mod - 2);

    }

}



ll ncr(ll n, ll r)

{

    return ((fact[n] * inv[r]) % mod * inv[n - r]) % mod;

}



ll npr(ll n, ll r)

{

    return (fact[n] * inv[n - r]) % mod;

}



int main()

{

    calcFacAndInv(100000);

     cout<<inv[3];

    return 0;

}

*/





// GCD



int gcd(long long a,long long b)

{

    if (b==0)

        return a;

    return gcd (b,a%b);

}

//fast power

/*

#define mod 1000000007

long long fp(long long  base, long long exp)

{

    if (exp == 0)

        return 1;

    long long  ans = fp(base, exp / 2);

    ans = (ans * ans);

    if (exp % 2 != 0)

        ans = (ans * (base )) ;

    return ans;

}

*/

//prime factoriation

/*

set<int >s;

bool prime factorization (int x)

{

    for (int j=2; j*j<=x; ++j)

    {

        while (x%j==0)

        {

            s.insert(j);

            x/=j;

        }

    }

    if (x>1)

    {

        s.insert(x);

    }

    if (s.size()==2)

        return true ;

    else

        return false ;

}



#define ll long long

int a,b,q,p,n;

int countDivisorss(int x,int y)

{

    ll cnt = 0;

    for (int i = min(x,y); i <= sqrt(n); i++)

    {

        if (x % i == 0&&y%i==0)

        {

            if (x / i == i||y / i == i)

                cnt++;



            else

                cnt = cnt + 2;

        }

    }

    return cnt;

}

int countDivisors(int x)

{

    ll cnt = 0;

    int tmp=n;

    if (n-x>10000000)  tmp=sqrt(n);

    for (int i = x; i <= tmp; i++)

    {

        if (x % i == 0)

        {

         if (x/i==i)

            cnt++;

         else

            cnt = cnt + 2;

        }

    }

    return cnt;

}

*/



/*

        int s =n/2,e=n-1;

        while (s<=e&&e<=n-1)

        {

            int mid =s+e/2;



            if (arr[mid]==arr[n/2])

            {

                s=mid;

                num +=mid -s;

            }

            else

                e=mid-1;

        }

        */









const int N = 1e5 + 5;



vector<int> adj[N];

bool visited[N];

int nodesNum;

void dfs(int node)

{

   if (visited[node])

       return;

   visited[node] = true;

   for (int child: adj[node])

       dfs(child);

}



int main()

{

   int n;

   cin>>n;

   if (n%2==0)

    cout<<n/2;

   else 

    cout<<n/2+1;

   return 0;

}






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

using namespace std;

int main()

{

	int n;

	cin>>n;

	cout<<(n+1)/2;

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



#define ll long long

#define ld long double

#define ull unsigned long long

#define endl "\n"

#define MohamedMotaz ios::sync_with_stdio(0); cin.tie(0); ios_base::sync_with_stdio(0);



using namespace std;



















int main()

{

	MohamedMotaz;

	ll x;

	cin >> x;

	cout << ceil(x / 2.0);





}








































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

#include <string.h>

int main()

{

    int n;

    scanf("%d",&n);

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

    return 0;

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

using namespace std;

typedef long long ll;   



int main()

{

    ll num;

    cin>>num;

    cout<<num/2 + num %2;

    return 0;

}

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

#include <string.h>

int main()

{

    int n;

    scanf("%d",&n);

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

    return 0;

}