#include <bits/stdc++.h>
namespace _ {
const long long inf = 1e17 + 7;
namespace _in {
template <class T>
inline T read() {
  char ch;
  bool flag = 0;
  T x = 0;
  while (ch = getchar(), !isdigit(ch))
    if (ch == '-') flag = 1;
  while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
  return flag ? -x : x;
}
struct {
  inline operator long long() { return read<long long>(); }
  inline operator int() { return read<int>(); }
  inline operator bool() { return read<bool>(); }
  template <class T>
  inline void operator()(T &x) {
    x = *this;
  }
  template <class T, class... A>
  inline void operator()(T &x, A &...a) {
    x = *this, this->operator()(a...);
  }
} IN;
}  // namespace _in
using namespace _in;
namespace _std {
template <class T>
inline void swap(T &x, T &y) {
  x ^= y ^= x ^= y;
}
template <class T>
inline void chkmax(T &x, T y) {
  if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, T y) {
  if (x > y) x = y;
}
template <class T>
inline T abs(T x) {
  if (x < 0) x = -x;
  return x;
}
template <class T>
inline T max(T x, T y) {
  if (x < y) x = y;
  return x;
}
template <class T>
inline T min(T x, T y) {
  if (x > y) x = y;
  return x;
}
}  // namespace _std
using namespace _std;
}  // namespace _
using namespace _;
const int N = 2e5 + 5;
int n, top, del[N];
long long S;
struct Factory {
  int v, c;
  bool operator!=(const Factory &b) { return v != b.v || c != b.c; }
} b[N], a[N];
inline void _solve1() {
  std::sort(b + 1, b + 1 + n, [](Factory a, Factory b) {
    return a.c == b.c ? a.v > b.v : a.c < b.c;
  });
  int m = 1, cnt = 0, las = b[1].v;
  for (int i = 2; i <= n; ++i)
    if (b[i] != b[m]) b[++m] = b[i];
  for (int i = 2; i <= m; ++i) {
    if (las >= b[i].v) del[i] = true;
    chkmax(las, b[i].v);
  }
  for (int i = 1; i <= m; ++i)
    if (!del[i]) a[++cnt] = b[i];
  n = cnt;
  std::sort(a + 1, a + 1 + n, [](Factory a, Factory b) {
    return a.v == b.v ? a.c < b.c : a.v < b.v;
  });
}
long long pos[N];
struct Line {
  long long k, c;
} sta[N];
inline long long calc(Line a, long long p) {
  return inf / a.k < p ? inf : a.k * p + a.c;
}
inline int get_pos(long long p) {
  int l = 1, r = top, ans = 1;
  while (l <= r)
    pos[((l + r) >> 1)] <= p                          ? ans = ((l + r) >> 1),
                               l = ((l + r) >> 1) + 1 : r = ((l + r) >> 1) - 1;
  return ans;
}
inline long long get_val(long long p) {
  long long l = 1, r = 1e16, ans = 0;
  while (l <= r)
    calc(sta[get_pos(((l + r) >> 1))], ((l + r) >> 1)) >= p
        ? ans = ((l + r) >> 1),
          r = ((l + r) >> 1) - 1 : l = ((l + r) >> 1) + 1;
  return ans;
}
inline long long get_cross(int i) {
  long long l = 0, r = 1e16, ans = 0;
  Line tmp = (Line){sta[top].k - sta[top - 1].k, sta[top].c - sta[top - 1].c};
  while (l <= r)
    calc(tmp, ((l + r) >> 1)) > 0 ? ans = ((l + r) >> 1), r = ((l + r) >> 1) - 1
                                  : l = ((l + r) >> 1) + 1;
  return ans;
}
int main() {
  IN(n), IN(S);
  for (int i = 1; i <= n; ++i) IN(b[i].v, b[i].c);
  _solve1();
  sta[top = 1] = (Line){a[1].v, 0}, pos[top] = 0;
  for (int i = 2; i <= n; ++i) {
    long long p = get_val(a[i].c);
    long long c = calc(sta[get_pos(p)], p) - a[i].c - a[i].v * p;
    while (top &&
           calc((Line){a[i].v - sta[top].k, c - sta[top].c}, pos[top]) >= 0)
      --top;
    sta[++top] = (Line){a[i].v, c}, pos[top] = get_cross(top);
  }
  printf("%lld\n", get_val(S));
  return 0;
}
