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



int main()

{

    int H, A, count=0;

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

    while (H > 0)

    {

        H = H - A;

        count++;

    }

    printf("%d",count);

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



int main()

{

    int H, A, count=0;

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

    while (H > 0)

    {

        H = H - A;

        count++;

    }

    printf("%d",count);

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

int main()

{

	int Health, Attack;

	scanf("%d %d", &Health, &Attack);

	

	if( Health%Attack==0) printf("%d",Health/Attack);

	else if (Health%Attack>0) printf("%d\n",Health/Attack+1);

	

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

int main()

{

	int Health, Attack;

	scanf("%d %d", &Health, &Attack);

	

	if( Health%Attack==0) printf("%d",Health/Attack);

	else if (Health%Attack>0) printf("%d\n",Health/Attack+1);

	

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

int main()

{

	int Health, Attack;

	scanf("%d %d", &Health, &Attack);

	

	if( Health%Attack==0) printf("%d",Health/Attack);

	else if (Health%Attack>0) printf("%d\n",Health/Attack+1);

	

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

int main()

{

	int Health, Attack;

	scanf("%d %d", &Health, &Attack);

	

	if( Health%Attack==0) printf("%d",Health/Attack);

	else if (Health%Attack>0) printf("%d\n",Health/Attack+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.338095423721358x):
#include <stdio.h>



int main()

{

	int H, A, X=0;

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

	while(H>0)

	{

		H=H-A;

		X++;

	}

	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(int i=h ; i>0 ; i-=a)

    {

        counter++;

    }

    cout<<counter;

    return 0;

}


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



int main()

{

	int H, A, X=0;

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

	while(H>0)

	{

		H=H-A;

		X++;

	}

	printf("%d", X);

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



int main()

{

	int H, A, X=0;

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

	while(H>0)

	{

		H=H-A;

		X++;

	}

	printf("%d", X);

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



int main()

{

	int H, A, X=0;

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

	while(H>0)

	{

		H=H-A;

		X++;

	}

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



int main(){

	int darah;

	int damage;

	int mantap;

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

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

	printf("%d", mantap);

	

	

	

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

	int damage;

	int mantap;

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

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

	printf("%d", mantap);

	

	

	

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

	int damage;

	int mantap;

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

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

	printf("%d", mantap);

	

	

	

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

	int damage;

	int mantap;

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

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

	printf("%d", mantap);

	

	

	

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

	int damage;

	int mantap;

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

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

	printf("%d", mantap);

	

	

	

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



int main (){

	int H,A;

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

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



int main (){

	int H,A;

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

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



int main (){

	int H,A;

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

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



int main (){

	int H,A;

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

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



int main (){

	int H,A;

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

	printf("%d", ((H-1)/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.255032935877765x):
#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;

    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.26565119816195x):
#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,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.265437406981707x):
#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 <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.248802625835436x):
#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>

#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.374240555838965x):
#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,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 h, a;

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



	(h%a == 0) ? printf("%d\n", h/a) : printf("%d\n", 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.26557657621841x):
#include<stdio.h>



int main(){

	int h, a;

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



	(h%a == 0) ? printf("%d\n", h/a) : printf("%d\n", 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.2653627880679x):
#include<stdio.h>



int main(){

	int h, a;

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



	(h%a == 0) ? printf("%d\n", h/a) : printf("%d\n", 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.248728242660696x):
#include<stdio.h>



int main(){

	int h, a;

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



	(h%a == 0) ? printf("%d\n", h/a) : printf("%d\n", 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.374164395026136x):
#include<stdio.h>



int main(){

	int h, a;

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



	(h%a == 0) ? printf("%d\n", h/a) : printf("%d\n", 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.263957417928137x):
#include <stdio.h>



int main() {



    int x,y;

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

    printf("%d", (x % y == 0 ? x / y : x / y+1));

    // if(x % y == 0) {

    //     printf("%d\n", x / y);

    // } else {

    //     printf("%d", x / y+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 x,y;

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

    printf("%d", (x % y == 0 ? x / y : x / y+1));

    // if(x % y == 0) {

    //     printf("%d\n", x / y);

    // } else {

    //     printf("%d", x / y+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 x,y;

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

    printf("%d", (x % y == 0 ? x / y : x / y+1));

    // if(x % y == 0) {

    //     printf("%d\n", x / y);

    // } else {

    //     printf("%d", x / y+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 x,y;

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

    printf("%d", (x % y == 0 ? x / y : x / y+1));

    // if(x % y == 0) {

    //     printf("%d\n", x / y);

    // } else {

    //     printf("%d", x / y+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 x,y;

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

    printf("%d", (x % y == 0 ? x / y : x / y+1));

    // if(x % y == 0) {

    //     printf("%d\n", x / y);

    // } else {

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



int main(){

   int H, A;

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

   int ans = H/A;

   ( H%A == 0 )? printf("%d", ans): printf("%d", ans+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.275215965176076x):
#include <stdio.h>



int main(){

   int H, A;

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

   int ans = H/A;

   ( H%A == 0 )? printf("%d", ans): printf("%d", ans+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.2750017856558635x):
#include <stdio.h>



int main(){

   int H, A;

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

   int ans = H/A;

   ( H%A == 0 )? printf("%d", ans): printf("%d", ans+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.258336788340688x):
#include <stdio.h>



int main(){

   int H, A;

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

   int ans = H/A;

   ( H%A == 0 )? printf("%d", ans): printf("%d", ans+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.384002569474128x):
#include <stdio.h>



int main(){

   int H, A;

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

   int ans = H/A;

   ( H%A == 0 )? printf("%d", ans): printf("%d", ans+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.263961295910751x):
#include <stdio.h>



int main(){

    int H, 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;

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



int main(){

    int H, 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,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.274383444328063x):
#include <stdio.h>



int main(){

    int H, 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 <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.257720400501622x):
#include <stdio.h>



int main(){

    int H, 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>

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



int main(){

    int H, 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,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.226332442581865x):
#include <stdio.h>



int main(){

	int x , y ,z = 0 ;

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

	while (x>0) {

		x-=y;

		z++;

	}

	printf ("%d",z);

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



int main(){

	int x , y ,z = 0 ;

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

	while (x>0) {

		x-=y;

		z++;

	}

	printf ("%d",z);

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



int main(){

	int x , y ,z = 0 ;

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

	while (x>0) {

		x-=y;

		z++;

	}

	printf ("%d",z);

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



int main(){

	int x , y ,z = 0 ;

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

	while (x>0) {

		x-=y;

		z++;

	}

	printf ("%d",z);

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



int main(){

	int x , y ,z = 0 ;

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

	while (x>0) {

		x-=y;

		z++;

	}

	printf ("%d",z);

	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.254257406387219x):
#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,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.264874101644966x):
#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;

}