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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

int main (){

	

	int health,damage,attacks;

	scanf ("%d",&health);



	scanf ("%d",&damage);

	

	attacks= health/damage; 

	



 	(attacks * damage>=health)?  printf("%d", attacks):printf ("%d",++attacks );

	



	

	return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

int main (){

	

	int health,damage,attacks;

	scanf ("%d",&health);



	scanf ("%d",&damage);

	

	attacks= health/damage; 

	



 	(attacks * damage>=health)?  printf("%d", attacks):printf ("%d",++attacks );

	



	

	return 0;

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

int main (){

	

	int health,damage,attacks;

	scanf ("%d",&health);



	scanf ("%d",&damage);

	

	attacks= health/damage; 

	



 	(attacks * damage>=health)?  printf("%d", attacks):printf ("%d",++attacks );

	



	

	return 0;

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

using namespace std;

int main(){

   int H,i;

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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



int main() {

    int mtr, sv;

     scanf("%d %d", &mtr, &sv);

     

     int bb= mtr%sv == 0;

     int aa= mtr/sv;

   

     bb ? printf("%d\n", aa) : printf("%d\n", aa+1);





    return 0;

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



using namespace std;



int main()

{

    int h,a;

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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



int main() {

    int mtr, sv;

     scanf("%d %d", &mtr, &sv);

     

     int bb= mtr%sv == 0;

     int aa= mtr/sv;

   

     bb ? printf("%d\n", aa) : printf("%d\n", aa+1);





    return 0;

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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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



int main() {

    int mtr, sv;

     scanf("%d %d", &mtr, &sv);

     

     int bb= mtr%sv == 0;

     int aa= mtr/sv;

   

     bb ? printf("%d\n", aa) : printf("%d\n", aa+1);





    return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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



int main() {

    int mtr, sv;

     scanf("%d %d", &mtr, &sv);

     

     int bb= mtr%sv == 0;

     int aa= mtr/sv;

   

     bb ? printf("%d\n", aa) : printf("%d\n", aa+1);





    return 0;

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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



int main() {

    int mtr, sv;

     scanf("%d %d", &mtr, &sv);

     

     int bb= mtr%sv == 0;

     int aa= mtr/sv;

   

     bb ? printf("%d\n", aa) : printf("%d\n", aa+1);





    return 0;

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

using namespace std;

int main(){

   int H,i;

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

int main() {

	int hp,dmg;

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

	hp % dmg == 0 ? printf("%d",hp/dmg) : printf("%d",(hp/dmg)+1);

	return 0;

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



using namespace std;



int main()

{

    int h,a;

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

int main() {

	int hp,dmg;

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

	hp % dmg == 0 ? printf("%d",hp/dmg) : printf("%d",(hp/dmg)+1);

	return 0;

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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

int main() {

	int hp,dmg;

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

	hp % dmg == 0 ? printf("%d",hp/dmg) : printf("%d",(hp/dmg)+1);

	return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

int main() {

	int hp,dmg;

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

	hp % dmg == 0 ? printf("%d",hp/dmg) : printf("%d",(hp/dmg)+1);

	return 0;

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

int main() {

	int hp,dmg;

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

	hp % dmg == 0 ? printf("%d",hp/dmg) : printf("%d",(hp/dmg)+1);

	return 0;

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

using namespace std;

int main(){

   int H,i;

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

using namespace std;



int main(){

	int h,a;

	cin >> h >> a;

	

	cout << (h+a-1)/a << endl;

	

	

	return 0;

}

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

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

int main(){

	int a,b;

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

	if(a%b==0){

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

	} else if(a<=b){

		printf("%d", 1);

	} else{

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

	}

	return 0;

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



using namespace std;



int main()

{

    int h,a;

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

int main(){

	int a,b;

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

	if(a%b==0){

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

	} else if(a<=b){

		printf("%d", 1);

	} else{

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

	}

	return 0;

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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

int main(){

	int a,b;

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

	if(a%b==0){

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

	} else if(a<=b){

		printf("%d", 1);

	} else{

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

	}

	return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

int main(){

	int a,b;

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

	if(a%b==0){

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

	} else if(a<=b){

		printf("%d", 1);

	} else{

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

	}

	return 0;

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

int main(){

	int a,b;

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

	if(a%b==0){

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

	} else if(a<=b){

		printf("%d", 1);

	} else{

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

	}

	return 0;

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

using namespace std;



int main(){

	int h,a;

	cin >> h >> a;

	

	cout << (h+a-1)/a << endl;

	

	

	return 0;

}

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

int main(){

	int a,b;

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

	if(a%b==0){

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

	} else if(a<=b){

		printf("%d", 1);

	} else{

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

	}

	return 0;

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

using namespace std;

int main(){

   int H,i;

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

int main(){

	int h;

	int a;

	int x;

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

	if(a>h){

		printf("1");

	}

	else if(h>=a){

		x = (h-1)/a+1;

		printf("%d", x);

	}



	return 0; 

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



using namespace std;



int main()

{

    int h,a;

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

int main(){

	int h;

	int a;

	int x;

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

	if(a>h){

		printf("1");

	}

	else if(h>=a){

		x = (h-1)/a+1;

		printf("%d", x);

	}



	return 0; 

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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

int main(){

	int h;

	int a;

	int x;

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

	if(a>h){

		printf("1");

	}

	else if(h>=a){

		x = (h-1)/a+1;

		printf("%d", x);

	}



	return 0; 

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

int main(){

	int h;

	int a;

	int x;

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

	if(a>h){

		printf("1");

	}

	else if(h>=a){

		x = (h-1)/a+1;

		printf("%d", x);

	}



	return 0; 

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

int main(){

	int h;

	int a;

	int x;

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

	if(a>h){

		printf("1");

	}

	else if(h>=a){

		x = (h-1)/a+1;

		printf("%d", x);

	}



	return 0; 

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

using namespace std;



int main(){

	int h,a;

	cin >> h >> a;

	

	cout << (h+a-1)/a << endl;

	

	

	return 0;

}

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

int main(){

	int h;

	int a;

	int x;

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

	if(a>h){

		printf("1");

	}

	else if(h>=a){

		x = (h-1)/a+1;

		printf("%d", x);

	}



	return 0; 

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

using namespace std;

int main(){

   int H,i;

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

using namespace std;



int main(){

	int h,a;

	cin >> h >> a;

	

	cout << (h+a-1)/a << endl;

	

	

	return 0;

}

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

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

int main ()

{

	int H,A,J,result;

	scanf("%d", &H);

	scanf("%d", &A);

	if(H%A==0){

		J=H/A;

		printf("%d",J);

	}

	else{

		result=(H/A)+1;

		printf("%d",result);

	}

return 0;

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



using namespace std;



int main()

{

    int h,a;

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

int main ()

{

	int H,A,J,result;

	scanf("%d", &H);

	scanf("%d", &A);

	if(H%A==0){

		J=H/A;

		printf("%d",J);

	}

	else{

		result=(H/A)+1;

		printf("%d",result);

	}

return 0;

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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

int main ()

{

	int H,A,J,result;

	scanf("%d", &H);

	scanf("%d", &A);

	if(H%A==0){

		J=H/A;

		printf("%d",J);

	}

	else{

		result=(H/A)+1;

		printf("%d",result);

	}

return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

int main ()

{

	int H,A,J,result;

	scanf("%d", &H);

	scanf("%d", &A);

	if(H%A==0){

		J=H/A;

		printf("%d",J);

	}

	else{

		result=(H/A)+1;

		printf("%d",result);

	}

return 0;

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

int main ()

{

	int H,A,J,result;

	scanf("%d", &H);

	scanf("%d", &A);

	if(H%A==0){

		J=H/A;

		printf("%d",J);

	}

	else{

		result=(H/A)+1;

		printf("%d",result);

	}

return 0;

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

using namespace std;



int main(){

	int h,a;

	cin >> h >> a;

	

	cout << (h+a-1)/a << endl;

	

	

	return 0;

}

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

int main ()

{

	int H,A,J,result;

	scanf("%d", &H);

	scanf("%d", &A);

	if(H%A==0){

		J=H/A;

		printf("%d",J);

	}

	else{

		result=(H/A)+1;

		printf("%d",result);

	}

return 0;

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

using namespace std;

int main(){

   int H,i;

   int a;

   cin>>H;

   cin>>a;

   for(i=1;a<H;i++){

       H-=a;

   }

   cout<<i;

}




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

int main()

{

	int H;

	int A;

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

	if(H%A ==0){

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

	}

	else if (H%A !=0){

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

	}

	return 0;

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



using namespace std;



int main()

{

    int h,a;

    int counter = 0;

    cin>>h >> a;

    for(; h>0;)

    {

        h = h - a ;

        counter = counter +1;



    }

    cout<<counter<<endl;

    return 0;

}


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

int main()

{

	int H;

	int A;

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

	if(H%A ==0){

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

	}

	else if (H%A !=0){

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

	}

	return 0;

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



using namespace std;



int main()

{

	





int H ,A,i=0;

cin>>H >>A ;

while (H>0) {

H=H-A;



i++;

 }

cout<< i << endl;

return 0;

}

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

int main()

{

	int H;

	int A;

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

	if(H%A ==0){

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

	}

	else if (H%A !=0){

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

	}

	return 0;

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

using namespace std;

int main()

{

    int a,b;

    cin>>a>>b;



    cout<<(a+b-1)/b;

    return 0;



}




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

int main()

{

	int H;

	int A;

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

	if(H%A ==0){

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

	}

	else if (H%A !=0){

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

	}

	return 0;

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

#include <cmath>

using namespace std;

int main()

{

    float h,a;

    cin >> h >> a;

    cout << ceil(h/a) <<endl;

    return 0;

}

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

int main()

{

	int H;

	int A;

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

	if(H%A ==0){

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

	}

	else if (H%A !=0){

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

	}

	return 0;

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

using namespace std;



int main(){

	int h,a;

	cin >> h >> a;

	

	cout << (h+a-1)/a << endl;

	

	

	return 0;

}

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

int main()

{

	int H;

	int A;

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

	if(H%A ==0){

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

	}

	else if (H%A !=0){

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

	}

	return 0;

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



using namespace std;



int main()

{

    int H,A;

    cin>>H>>A;

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

    return 0;

}


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



int main () {

    

   int A, H, n;

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

    

    n=H/A;

    

    if(H%A==0)

     printf("%d", n);

    else

     {n++;

    

   printf("%d", n);}

return 0;

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



using namespace std;



int main()

{

    int H,A;

    cin>>H>>A;

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

    return 0;

}


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



int main(){

    int h, a;

    int hit = 0;

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

    hit = h/a;

    if(h%a != 0){

        hit++;

    }

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

    

    return 0;

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



using namespace std;



int main() {



    double a,b;

    cin>>a>>b;

    cout<<int(ceil(a/b));

    

    return 0;

}


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



int main(){

    int h, a;

    int hit = 0;

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

    hit = h/a;

    if(h%a != 0){

        hit++;

    }

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

    

    return 0;

}