//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;

#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);


// 基本テンプレート
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
//#define rep(i,n) for(int i=0; i<(int)n; ++i)
//#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
//#define repi(i,n) for(int i=0; i<=(int)n; ++i)
//#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
//#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define mp make_pair
#define VAR(type, a) type a;std::cin>>a;
#define VAR2(type, a, b) VAR(type, a); VAR(type, b);
#define VAR3(type, a, b, c) VAR(type, a); VAR(type, b); VAR(type, c);
#define VAR4(type, a, b, c, d) VAR(type, a); VAR(type, b); VAR(type, c); VAR(type, d);
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;
#define FOR(i,a,b) for (int i=(a);i<(b);++i)
#define FORI(i,a,b) for (int i=(a);i<=(b);++i)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);--i)
#define REP(i,n) for (int i=0;i<(n);++i)
#define REPI(i,n) for (int i=0;i<=(n);++i)
#define REP1(i,n) for (int i=1;i<(n);++i)
#define RREP(i,n) for (int i=(n)-1;i>=0;--i)

// 型
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;



// Effective std
template<typename C, typename T> int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F> int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T> void erase(C& c, T t) { remove(ALL(c), t), c.end(); }
template<typename C> void remove(vector<C>& c, unsigned int index) { c.erase(c.begin()+index); }
template<typename C, typename T, typename U> void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U> void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C> void reverse(C& c) { reverse(ALL(c)); }
template<typename C, typename Pred> void sort(C& c, Pred p) { sort(ALL(c), p); }
template<typename T> inline istream& operator>>(istream &s, vector<T> &v) { for (T &t : v) s >> t; return s; }
template<typename T> inline ostream& operator<<(ostream &s, const vector<T> &v) { for (const T &t : v) s << t << endl; return s; }
template<typename T> inline T fromString(const string &s) {T res; istringstream iss( s ); iss >> res; return res; }
template<typename T> inline string toString(const T &a) {ostringstream oss; oss << a; return oss.str(); }
template<typename T> inline bool chmin(T &a, const T &b){if (b < a) {a = b; return true;} return false; }
template<typename T> inline bool chmax(T &a, const T &b){if (a < b) {a = b; return true;} return false; }
template<typename T> inline T min(vector<T>& v) {return *min_element(v.begin(), v.end());}
template<typename T> inline T max(vector<T>& v) {return *max_element(v.begin(), v.end());}
template<typename T> inline T sum(vector<T>& v) {return accumulate(v.begin(), v.end(), 0);}
template<typename T> inline void sort(vector<T>& v) {sort(v.begin(), v.end());}
//template<typename T, typename Function> inline void sort(vector<T>& v, Function func) {sort(v.begin(), v.end(), func);}
template<typename T> inline void rsort(vector<T>& v) {sort(v.rbegin(), v.rend());}
//template<typename T> inline void reverse(vector<T>& v) {reverse(v.begin(), v.end());}
template<typename T> inline void unique(vector<T>& v) {v.erase(unique(v.begin(), v.end()), v.end());}
template<typename T> inline void nth_element(vector<T>& v, int n) {nth_element(v.begin(), v.begin() + n, v.end());}
template<typename T> inline bool next_permutation(vector<T>& v) {return next_permutation(v.begin(), v.end());}
template<typename T> inline int find(vector<T>& v, T t) {return find(v.begin(), v.end(), t) - v.begin();}
template<typename T> inline int in(vector<T> v, T t) {return find(v, t) != (int)v.size();}
template<typename T> inline int lower_bound(vector<T>& v, T t) {return lower_bound(v.begin(), v.end(), t) - v.begin();}
template<typename T> inline int upper_bound(vector<T>& v, T t) {return upper_bound(v.begin(), v.end(), t) - v.begin();}
template<typename T> inline T accumulate(const vector<T>& v) {return accumulate(v.begin(), v.end(), T(0));}
template<typename T> inline void adjacent_difference(vector<T>& v, vector<T>& u) {adjacent_difference(v.begin(), v.end(), u.begin());}
template<typename T> inline void partial_sum(vector<T>& v, vector<T>& u) {partial_sum(v.begin(), v.end(), u.begin());}
template<typename T> inline T inner_product(vector<T>& v, vector<T>& u) {return inner_product(v.begin(), v.end(), u.begin(), T(0));}
//template<typename T, typename Function> inline int count_if(vector<T> v, Function func) {return count_if(v.begin(), v.end(), func);}
template<typename T, typename Function> inline void remove_if(vector<T>& v, Function func) {v.erase(remove_if(v.begin(), v.end(), func), v.end());}
template<typename T, typename Function> inline bool any_of(vector<T> v, Function func) {return any_of(v.begin(), v.end(), func);}
template<typename T>T get(){T a;cin>>a;return a;}
#define PB push_back
#define EM emplace
#define EB emplace_back
#define BI back_inserter
#define MP make_pair
#define fst first
#define snd second
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl

// 定数
constexpr int PI = (2*acos(0.0));
constexpr int EPS = (1e-9);
constexpr int MOD = (int)(1e9+7);
constexpr int INF = 100000000;


int main(){
	INIT;

    VAR2(int, s, f);
    P(s / f + 1);


    return 0;
}