stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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



int main (){

	int health;

	int damage;

	int valueHit = 0; 

	

	scanf("%d %d", &health, &damage);

	

	health%damage == 0?printf("%d", health/damage) : printf("%d", health/damage +1);

	

	

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main(){

	int nyawa, pukul;

	scanf("%d %d", &nyawa,&pukul);

	int mati = nyawa / pukul;

	nyawa % pukul == 0 ? printf("%d", mati) : printf("%d", mati + 1);

	

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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



int main(){

	int H,A;

	scanf("%d %d", &H, &A);

	printf("%d", (((H-1)+A)/A));



	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main() {



	int x;

	int y;

	scanf("%d%d", &x,&y);

	

	 

	 

	 if(x%y==0) {

		printf("%d",(x/y));}

		

	 else if(x>y) {

		printf("%d", (x/y)+1);

	}

	

	else if(x<y) {

			printf("%d", 1);

	}





 return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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





int main ()

{

int H,A,J;



scanf("%d %d", &H, &A);

J=H/A;



if (H%A==0){

	printf("%d", J);

}

else if(H%A!=0){

	J++;

	printf("%d", J);

}







	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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



int main(){

	int H,A;

	scanf("%d %d",&H,&A);

	if(H%A>0){

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

	}

	else{

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

	}

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main () 

{

int h, a;

scanf("%d %d", &h, &a) ;

if (h%a == 0) {

printf("%d\n", h/a) ;

}

else {

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

}

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main()

{

	int A,H;

	scanf("%d %d",&H,&A);

	if(H%A==0)

	{

		printf("%d",H/A);

	}

	else 

	{

		printf("%d",H/A+1);

	}

	

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main(){

	int health;

	int attack;

	int turn = 0;

	scanf("%d %d", &health, &attack);

	while(health > 0){

		health = health - attack;

		turn = turn + 1;} 

	printf("%d", turn);

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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



int main (){

	

	int h, a;

	scanf("%d %d", &h, &a);

	

	printf ("%d\n", (h + a - 1) / a );

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main (){

	int H,A,yeet=0;

		scanf("%d",&H);

		scanf("%d",&A);

	while(H > 0)

	{

	H = H - A;

	yeet++;

	

		}

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

	

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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

int main(){

	int X;

	int Y;

	scanf("%d %d",&X,&Y);

	int total = (X-1)/Y+1;

	printf("%d",total);

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.374024000418108x):


#include <stdio.h>

int main(){

	int H;

	int A;

	scanf("%d %d",&H,&A);

	

	int c=H/A;

	if(H%A !=0){

		c++;

	}

	printf("%d",c);

	

	return 0;

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

using namespace std;

int main(){

	

		double h,b;

		cin>>h>>b;

		cout<<ceil(h/b);

	return 0;

}

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



int main(){



    int H;

    int A;



    scanf("%d %d", &H, &A);



    if(H % A == 0){

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

}

    else{

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

    }



    return 0;



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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main() {

	int H, A;

	scanf("%d %d", &H, &A);

	if(H%A == 0){

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

	}else{

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

	}

	

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

#include <string.h>



int main(){

	int H, A, mod, attack;

	scanf("%d %d", &H, &A);

	getchar();

	

	mod = H % A;

	attack = H / A;

	mod == 0 ? printf("%d", attack) : printf("%d", attack+1); 

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main(){

	int h, a;

	scanf("%d %d", &h, &a);

	int check=0;

	check=h-a;

	if(check<0){

		printf("1\n");

	}

	else{

		if(h%a==0){

			printf("%d\n", h/a);

		}

		else{

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

		}

	}

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main(){

	

	int H;

	int A;

	scanf("%d%d", &H, &A);

	

	H%A == 0 ? H=H/A : H=(H/A)+1;

	printf("%d", H);

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

#include <string.h>



int main(){

	int a, b;

	scanf("%d %d", &a, &b);

	if(a % b ==0){

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

	}else{

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

	}



	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main(){

	

	int H, A;

	scanf("%d %d", &H, &A);

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





	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

 

int main () {

	int H,A;

	scanf("%d %d", &H,&A);

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

	

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main(){

	int darah;

	int damage;

	int finish;

	scanf("%d %d", &darah, &damage);

	finish=darah%damage==0? finish=darah/damage : finish=darah/damage+1;

	printf("%d", finish);

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main(){

	int hp, atk;

	scanf("%d %d", &hp, &atk);

	if(hp%atk != 0){

		printf("%d", hp/atk+1);

	} else {

		printf("%d", hp/atk);

	}

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main() {

	int chi, kougeki, kaunta;

	scanf("%d %d", &chi, &kougeki);

	kaunta = 1;

	chi % kougeki == 0 ? printf("%d", chi/kougeki) : printf("%d", (chi/kougeki)+1);

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

#include <string.h>



int main(){

	

	int Atk, Hth;

	scanf ("%d %d", &Atk, &Hth);

	

	int Tot = Atk/Hth;

	

	int Rst = Atk % Hth;

	

	Rst > 0 ? printf("%d", Tot+1) : printf("%d", Tot);

	

	return 0 ;

}



//  \N JANGAN LUPA!!!!!
// Slower C++ solution:
#include <iostream>

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main (){

	int H, A, hasil;

	

	scanf ("%d %d", &H,&A);

	hasil= ((H-1)/A+1);

	

	printf ("%d", hasil);

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main(){

	int n, k;

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

	int total = (n+k-1)/k;

	printf("%d", total);

	

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main(){

    int H;

    int A;

    scanf("%d %d", &H, &A);

    printf("%d", H%A == 0 ? H/A : H/A + 1);

 

    return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main(){

 int hel, dmg;

 int atcknum,sisadarah;

 scanf("%d %d", &hel,&dmg);



atcknum = hel/dmg;

sisadarah = hel%dmg;



sisadarah > 0 ? printf("%d",atcknum +1) :printf("%d",atcknum);

  return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main()

{

 int H,A,b;

 scanf("%d %d",&H,&A);

 if(H%A==0)

 {

 	printf("%d",H/A);

 }

 else 

 {

 	printf("%d",(H/A)+1	);

 }

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main(){

int a,b;

scanf("%d%d", &a, &b);

if(a%b==0)printf("%d\n",a/b);

else printf("%d\n", a/b+1);

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main(){

	int h,a,i,total;

	scanf ("%d",&h);

	scanf ("%d",&a);

	if (h%a==0){

		i=h/a;

		printf ("%d",i);

	}

	else{

		total = (h/a)+1;

		printf ("%d",total);

	}

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main(){

int H,A;

scanf("%d %d",&H, &A);

if (H%A != 0){

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

}

else {

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

}

return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main()

{

int a,b,value;

scanf("%d %d",&a,&b);

if(a<=b){

    printf("1");

}else if(a>b){

    value=(a-1)/b+1;

    printf("%d",value);

}

return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main()

{	

	int x,y,z;

	scanf("%d %d", &x, &y);

	if(x<y){

		printf("1");

	}

	else if(x>=y){

		z=(x-1)/y+1;

		printf("%d", z);

	} 

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

int main()

{

  int H,A;

  scanf("%d", &H);

  scanf("%d", &A);



  int I=0;

  for(; H>0;)

  { 

    H=H-A;

    I=I+1;

  }

  printf("%d",I);

  return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main()

{

	int H;

	int A;

	int X;

	scanf("%d %d",&H,&A);

	X= H / A;

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

	if(H % A == 0 )

	{

		printf("%d",X);

	}

	else

	{

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

	}

	

	return 0;	

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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

  

int main(){  

int H;

int A;

scanf("%d %d",&H,&A);

  

if(H%A==0){

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

}

else{

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

}



    return 0;  

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main() 

{

	int x, y;

		scanf("%d %d", &x, &y);

	int z = x / y;

	

	if (x % y != 0) {

			z ++;

	}

		printf("%d", z);

	return 0;

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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main()

{

	int p, q, r;

	scanf("%d %d", &p, &q);

	while (p>0)

   {

       	p = p-q;

		r++;

   }

    

	printf("%d", r);

    return 0;

    



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

using namespace std;







int main()

{

   int H , A,coun = 0;

   cin>>H>>A;



   for( int i =0; H>0;i++)

   {

       H = H - A;

       coun+=1;

   }

   cout<<coun;





    return 0;

}

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



int main()

{

	int H, A;

	scanf("%d %d", &H, &A);

	

	if(H % A == 0)

	{

		printf("%d", H / A);

	}

	else

	{

		printf("%d", H / A + 1);

	}

	

	return 0;

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

# include <cmath>

using namespace std;



int main()

{

	float x,y; cin>>x>>y;

	cout<<ceil(x/y);

}


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



int main()

{

	int n, m;

	

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

	

	int sum;

	

	n % m != 0 ? sum = (n/m) + 1 : sum = n/m;

	

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

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



using namespace std;



int main()

{

    int h, a ;

    int counter =0;

    cin>>h>>a;

    for(int i=h ; i>0 ; i-=a)

    {

        counter++;

    }

    cout<<counter;

    return 0;

}


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



int main()

{

	int n, m;

	

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

	

	int sum;

	

	n % m != 0 ? sum = (n/m) + 1 : sum = n/m;

	

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

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



using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    if(a%b==0)

    {

        cout<<a/b<<endl;

    }

    else

    {

        cout<<a/b+1<<endl;

    }

    return 0;

}


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



int main()

{

	int n, m;

	

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

	

	int sum;

	

	n % m != 0 ? sum = (n/m) + 1 : sum = n/m;

	

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

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

using namespace std;

int main()

{



		int h,a;

		cin>>h>>a;

		int ans=h/a;

		h=h%a;

		if(h>0)

		ans++;

		cout<<ans;

}

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



int main()

{

	int n, m;

	

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

	

	int sum;

	

	n % m != 0 ? sum = (n/m) + 1 : sum = n/m;

	

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

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

# include <cmath>

using namespace std;



int main()

{

	float x,y; cin>>x>>y;

	cout<<ceil(x/y);

}


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



int main (){

	int H, A, hasil;

	

	scanf ("%d %d", &H,&A);

	

	int hasil1= H/A;

	int hasil2 = H/A+1;

	

	H%A==0 ? printf ("%d",hasil1) : printf ("%d",hasil2);

	

	return 0;

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



using namespace std;



int main()

{

    int h, a ;

    int counter =0;

    cin>>h>>a;

    for(int i=h ; i>0 ; i-=a)

    {

        counter++;

    }

    cout<<counter;

    return 0;

}


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



int main (){

	int H, A, hasil;

	

	scanf ("%d %d", &H,&A);

	

	int hasil1= H/A;

	int hasil2 = H/A+1;

	

	H%A==0 ? printf ("%d",hasil1) : printf ("%d",hasil2);

	

	return 0;

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



using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    if(a%b==0)

    {

        cout<<a/b<<endl;

    }

    else

    {

        cout<<a/b+1<<endl;

    }

    return 0;

}


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



int main (){

	int H, A, hasil;

	

	scanf ("%d %d", &H,&A);

	

	int hasil1= H/A;

	int hasil2 = H/A+1;

	

	H%A==0 ? printf ("%d",hasil1) : printf ("%d",hasil2);

	

	return 0;

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

using namespace std;

int main()

{



		int h,a;

		cin>>h>>a;

		int ans=h/a;

		h=h%a;

		if(h>0)

		ans++;

		cout<<ans;

}

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



int main (){

	int H, A, hasil;

	

	scanf ("%d %d", &H,&A);

	

	int hasil1= H/A;

	int hasil2 = H/A+1;

	

	H%A==0 ? printf ("%d",hasil1) : printf ("%d",hasil2);

	

	return 0;

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

# include <cmath>

using namespace std;



int main()

{

	float x,y; cin>>x>>y;

	cout<<ceil(x/y);

}


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



int main() {

    int H, A, n;

    scanf("%d %d", &H, &A);

    n = H % A == 0 ? (H / A) : (H / A) + 1;

    printf("%d", n);

    return 0;

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



using namespace std;



int main()

{

    int h, a ;

    int counter =0;

    cin>>h>>a;

    for(int i=h ; i>0 ; i-=a)

    {

        counter++;

    }

    cout<<counter;

    return 0;

}


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



int main() {

    int H, A, n;

    scanf("%d %d", &H, &A);

    n = H % A == 0 ? (H / A) : (H / A) + 1;

    printf("%d", n);

    return 0;

}