#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
template <class T>
bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
class MonotoneCHT {
 public:
  struct line {
    T a, b;
    line(T a, T b) : a(a), b(b) {}
    bool operator<(const line& r) const {
      return (a != r.a ? a < r.a : b < r.b);
    }
    bool operator>(const line& r) const {
      return (a != r.a ? a > r.a : b > r.b);
    }
  };
  vector<line> lines;
  bool isMonotonicX;
  function<bool(T l, T r)> comp;

 public:
  MonotoneCHT(bool flagX, function<bool(T l, T r)> compFunc)
      : isMonotonicX(flagX), comp(compFunc) {}
  bool check(line l1, line l2, line l3) {
    if (l1 < l3) swap(l1, l3);
    return (long double)(l3.b - l2.b) * (l2.a - l1.a) <=
           (long double)(l2.b - l1.b) * (l3.a - l2.a);
  }
  void add(T a, T b) {
    line l(a, b);
    while (lines.size() >= 2 && check(*(lines.end() - 2), lines.back(), l))
      lines.pop_back();
    lines.emplace_back(l);
  }
  T f(int i, T x) { return lines[i].a * x + lines[i].b; }
  T f(line l, T x) { return l.a * x + l.b; }
  T get(T x) {
    if (isMonotonicX) {
      static int head = 0;
      while (lines.size() - head >= 2 && comp(f(head, x), f(head + 1, x)))
        head++;
      return f(head, x);
    } else {
      int l = -1, r = lines.size() - 1;
      while (l + 1 < r) {
        int m = (l + r) / 2;
        (comp(f(m, x), f(m + 1, x)) ? l : r) = m;
      }
      return f(r, x);
    }
  }
};
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int N;
  cin >> N;
  vec<ll> X(N), Y(N);
  for (int i = 0; i < N; i++) cin >> X[i] >> Y[i];
  if (N == 1) {
    cout << 0 << "\n";
    return 0;
  }
  map<ll, ll> mp;
  for (int i = 0; i < N; i++) {
    if (!mp.count(-X[i]))
      mp[-X[i]] = Y[i] - X[i] * X[i];
    else
      chmax(mp[-X[i]], Y[i] - X[i] * X[i]);
  }
  MonotoneCHT<ll> cht(true, [](ll a, ll b) { return a < b; });
  for (auto& [a, b] : mp) cht.add(a, b);
  int n = cht.lines.size();
  cout << (int)cht.lines.size() - 1 << "\n";
}
