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.266208630249345x):
#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<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.217496796576196x):
#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>

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

int main(){

    int health, damage;

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

    int attack = health/ damage;

    health % damage == 0 ? printf("%d\n",attack) : printf("%d\n",++attack);

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

int main(){

    int health, damage;

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

    int attack = health/ damage;

    health % damage == 0 ? printf("%d\n",attack) : printf("%d\n",++attack);

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

int main(){

    int health, damage;

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

    int attack = health/ damage;

    health % damage == 0 ? printf("%d\n",attack) : printf("%d\n",++attack);

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

int main(){

    int health, damage;

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

    int attack = health/ damage;

    health % damage == 0 ? printf("%d\n",attack) : printf("%d\n",++attack);

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



int main(){

	int H,A, X;

	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 ;

    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, X;

	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 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, X;

	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()

{



		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, X;

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



int main(){

	int h, a;

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



	(h%a == 0) ? printf("%d", h/a) : 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(int i=h ; i>0 ; i-=a)

    {

        counter++;

    }

    cout<<counter;

    return 0;

}


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



int main(){

	int h, a;

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



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



int main(){

	int h, a;

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



	(h%a == 0) ? printf("%d", h/a) : 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;

		int ans=h/a;

		h=h%a;

		if(h>0)

		ans++;

		cout<<ans;

}

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



int main(){

	int h, a;

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



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



int main(){

	

	int a, b, c;

	

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

	

	c= (a/b);

	a%b > 0 ? printf("%d", c+1) : printf ("%d", c);

	

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



int main(){

	

	int a, b, c;

	

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

	

	c= (a/b);

	a%b > 0 ? printf("%d", c+1) : printf ("%d", c);

	

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



int main(){

	

	int a, b, c;

	

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

	

	c= (a/b);

	a%b > 0 ? printf("%d", c+1) : printf ("%d", c);

	

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



int main(){

	

	int a, b, c;

	

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

	

	c= (a/b);

	a%b > 0 ? printf("%d", c+1) : printf ("%d", c);

	

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



int main(){

	

	int a, b, ans;

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

	

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

	printf("%d", ans);

	

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



int main(){

	

	int a, b, ans;

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

	

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

	printf("%d", ans);

	

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



int main(){

	

	int a, b, ans;

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

	

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

	printf("%d", ans);

	

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



int main(){

	

	int a, b, ans;

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

	

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

	printf("%d", ans);

	

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

int main()

{

	int H,A;

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

	H%A<=0?printf("%d",H/A):printf("%d",H/A +1);//kalo yang pertama kondisi contoh 10/5 jdi habis kalo kondisi kedua contoh 10/4 jdi sisa dan harus ditambah 1 kali atatck

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

int main()

{

	int H,A;

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

	H%A<=0?printf("%d",H/A):printf("%d",H/A +1);//kalo yang pertama kondisi contoh 10/5 jdi habis kalo kondisi kedua contoh 10/4 jdi sisa dan harus ditambah 1 kali atatck

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

int main()

{

	int H,A;

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

	H%A<=0?printf("%d",H/A):printf("%d",H/A +1);//kalo yang pertama kondisi contoh 10/5 jdi habis kalo kondisi kedua contoh 10/4 jdi sisa dan harus ditambah 1 kali atatck

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

int main()

{

	int H,A;

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

	H%A<=0?printf("%d",H/A):printf("%d",H/A +1);//kalo yang pertama kondisi contoh 10/5 jdi habis kalo kondisi kedua contoh 10/4 jdi sisa dan harus ditambah 1 kali atatck

	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.366835558186731x):
#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 <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.21702313997359x):
#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<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.257291336167831x):
#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()

{



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

int main(){

	int health;

	int attack;

	int total;

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

	health%attack > 0 ? printf("%d", health/attack + 1) : printf("%d", health/attack);

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

int main(){

	int health;

	int attack;

	int total;

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

	health%attack > 0 ? printf("%d", health/attack + 1) : printf("%d", health/attack);

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

int main(){

	int health;

	int attack;

	int total;

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

	health%attack > 0 ? printf("%d", health/attack + 1) : printf("%d", health/attack);

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

int main(){

	int health;

	int attack;

	int total;

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

	health%attack > 0 ? printf("%d", health/attack + 1) : printf("%d", health/attack);

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



int main (){



	int a,b,i=0;

	

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

	

	while(a>0){

		a=a-b;

		i++;

	}

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

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



int main (){



	int a,b,i=0;

	

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

	

	while(a>0){

		a=a-b;

		i++;

	}

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

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



int main (){



	int a,b,i=0;

	

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

	

	while(a>0){

		a=a-b;

		i++;

	}

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

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



int main (){



	int a,b,i=0;

	

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

	

	while(a>0){

		a=a-b;

		i++;

	}

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

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



int main(){

	

	int h;

	int a;

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

	int d;

	d = h % a;

	int c;

	c = h / a;



	

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

	

	

	

	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;

	int a;

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

	int d;

	d = h % a;

	int c;

	c = h / a;



	

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

	

	

	

	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;

	int a;

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

	int d;

	d = h % a;

	int c;

	c = h / a;



	

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

	

	

	

	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;

	int a;

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

	int d;

	d = h % a;

	int c;

	c = h / a;



	

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

	

	

	

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



int main(){

	int h,a,d,c;

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

	d = h % a;

	c=h/a;

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

}
// 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,d,c;

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

	d = h % a;

	c=h/a;

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

}
// 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,d,c;

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

	d = h % a;

	c=h/a;

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

}
// 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,d,c;

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

	d = h % a;

	c=h/a;

	if(d>=1){

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

	}

	if(d<1){

		printf("%d",c);

	}

	

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

int main()

{

	int x, y, z;

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

	while (x>0)

	{

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

    {

        counter++;

    }

    cout<<counter;

    return 0;

}


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

int main()

{

	int x, y, z;

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

	while (x>0)

	{

		x = x-y;

		z++;

	}

	printf("%d", z);

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

int main()

{

	int x, y, z;

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

	while (x>0)

	{

		x = x-y;

		z++;

	}

	printf("%d", z);

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

int main()

{

	int x, y, z;

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

	while (x>0)

	{

		x = x-y;

		z++;

	}

	printf("%d", z);

	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, count=0;

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

    while (H > 0)

    {

        H = H - A;

        count++;

    }

    printf("%d",count);

    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, count=0;

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

    while (H > 0)

    {

        H = H - A;

        count++;

    }

    printf("%d",count);

    return 0;

}