#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
  long long res = 1;
  while (y) {
    if (y & 1) res = (res * x) % 1000000007;
    y = y / 2, x = (x * x) % 1000000007;
  }
  return res % 1000000007;
}
struct ConvexHullDynamic {
  static const long long INF = 1e18;
  struct Line {
    long long a, b;
    double xLeft;
    enum Type { line, maxQuery, minQuery } type;
    long long val;
    explicit Line(long long aa = 0, long long bb = 0)
        : a(aa), b(bb), xLeft(-INF), type(Type::line), val(0) {}
    long long valueAt(long long x) const {
      if (a >= (1e18) / x) return 1e18;
      return a * x + b;
    }
    friend bool isParallel(const Line &l1, const Line &l2) {
      return l1.a == l2.a;
    }
    friend double llersectX(const Line &l1, const Line &l2) {
      return isParallel(l1, l2) ? INF : 1.0 * (l2.b - l1.b) / (l1.a - l2.a);
    }
    bool operator<(const Line &l2) const {
      if (l2.type == line) return this->a < l2.a;
      if (l2.type == maxQuery) return this->xLeft < l2.val;
      return this->xLeft > l2.val;
    }
  };
  bool isMax;
  set<Line> hull;
  bool hasPrev(set<Line>::iterator it) { return it != hull.begin(); }
  bool hasNext(set<Line>::iterator it) {
    return it != hull.end() && next(it) != hull.end();
  }
  bool irrelevant(const Line &l1, const Line &l2, const Line &l3) {
    return llersectX(l1, l3) <= llersectX(l1, l2);
  }
  bool irrelevant(set<Line>::iterator it) {
    return hasPrev(it) && hasNext(it) &&
           ((isMax && irrelevant(*prev(it), *it, *next(it))) ||
            (!isMax && irrelevant(*next(it), *it, *prev(it))));
  }
  set<Line>::iterator updateLeftBorder(set<Line>::iterator it) {
    if (isMax && !hasPrev(it) || !isMax && !hasNext(it)) return it;
    double val = llersectX(*it, isMax ? (*prev(it)) : (*next(it)));
    Line temp(*it);
    it = hull.erase(it);
    temp.xLeft = val;
    it = hull.insert(it, temp);
    return it;
  }
  explicit ConvexHullDynamic(bool isMax) : isMax(isMax) {}
  void addLine(long long a, long long b) {
    Line l3 = Line(a, b);
    auto it = hull.lower_bound(l3);
    if (it != hull.end() && isParallel(*it, l3)) {
      if (isMax && it->b < b || !isMax && it->b > b)
        it = hull.erase(it);
      else
        return;
    }
    it = hull.insert(it, l3);
    if (irrelevant(it)) {
      hull.erase(it);
      return;
    }
    while (hasPrev(it) && irrelevant(prev(it))) hull.erase(prev(it));
    while (hasNext(it) && irrelevant(next(it))) hull.erase(next(it));
    it = updateLeftBorder(it);
    if (hasPrev(it)) updateLeftBorder(prev(it));
    if (hasNext(it)) updateLeftBorder(next(it));
  }
  long long getBest(long long x) {
    Line q;
    q.val = x;
    q.type = isMax ? Line::Type::maxQuery : Line::Type::minQuery;
    auto bestLine = hull.lower_bound(q);
    if (isMax) --bestLine;
    return bestLine->valueAt(x);
  }
};
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
  if (a.second < b.second) return true;
  if (a.second == b.second) return a.first > b.first;
  return false;
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  ConvexHullDynamic ds(1);
  long long n, s, i;
  cin >> n >> s;
  pair<long long, long long> arr[n];
  for (i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
  sort(arr, arr + n, cmp);
  vector<pair<long long, long long> > temp;
  i = 0;
  long long j;
  while (i < n) {
    j = i;
    temp.push_back(arr[j]);
    while (j < n and arr[j].second == arr[i].second) j++;
    i = j;
  }
  vector<pair<long long, long long> > fin;
  fin.push_back(temp[0]);
  long long prev = temp[0].first;
  for (i = 1; i < temp.size(); i++) {
    if (temp[i].first <= prev)
      continue;
    else
      fin.push_back(temp[i]), prev = temp[i].first;
  }
  ds.addLine(fin[0].first, 0);
  for (i = 1; i < fin.size(); i++) {
    long long low = 0, high = 1e18;
    long long ans = high;
    while (low <= high) {
      long long mid = (low + high) / 2;
      if (ds.getBest(mid) >= fin[i].second)
        ans = mid, high = mid - 1;
      else
        low = mid + 1;
    }
    long long c = ds.getBest(ans) - fin[i].second - fin[i].first * ans;
    ds.addLine(fin[i].first, c);
  }
  long long low = 0, high = 1e18;
  long long ans = high;
  while (low <= high) {
    long long mid = (low + high) / 2;
    if (ds.getBest(mid) >= s)
      ans = mid, high = mid - 1;
    else
      low = mid + 1;
  }
  cout << ans;
}
