#define MOD 1000000007
// #include <atcoder/all>

#if 1
//------------------------------------------------------------
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;

template <class T> struct Entry {
  static void Run() { T().Run(); }
};
struct MyMain;

#if defined(TEST)
#include "test.hpp"
extern istream &mis;
extern ostream &mos;
#else
istream &mis = cin;
ostream &mos = cout;
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(16);
  Entry<MyMain>::Run();
  return 0;
}
#endif

//------------------------------------------------------------
using ll = long long;
// #define int ll

#define FOR(i, s, e) for (ll i = ll(s); i < ll(e); ++i)
#define RFOR(i, s, e) for (ll i = ll(e) - 1; i >= ll(s); --i)
#define REP(i, n) for (ll i = 0, i##_size = ll(n); i < i##_size; ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)

#define INF INT64_MAX

//------------------------------------------------------------
template <class T> struct arr : public vector<T> {
  arr() {}
  arr(initializer_list<T> il) : vector<T>(il) {}
  explicit arr(ll n, T v = T()) : vector<T>(n, v) {}

  T &operator()(int i) { return (*this)[i]; }
  T const &operator()(int i) const { return (*this)[i]; }
  void init(ll n, T v = T()) {
    this->clear();
    this->resize(n, v);
  }
  ll sz() const { return (ll)this->size(); }
  void pb(T v) { this->push_back(v); }
  void sort() { std::sort(this->begin(), this->end()); }
  void sort(function<bool(T, T)> p) {
    std::sort(this->begin(), this->end(), p);
  }
  void rsort() { std::sort(this->begin(), this->end(), greater<T>()); }
  void reverse() { std::reverse(this->begin(), this->end()); }
  void unique_erase() {
    this->erase(std::unique(this->begin(), this->end()), this->end());
  }
  bool next_permutation() {
    return std::next_permutation(this->begin(), this->end());
  }

  // これ以下はソート済み前提
  int lower_bound(T const &v, function<bool(T, T)> p) {
    return std::lower_bound(this->begin(), this->end(), v, p) - this->begin();
  }
  int lower_bound(T const &v) {
    return std::lower_bound(this->begin(), this->end(), v) - this->begin();
  }

  int upper_bound(T const &v, function<bool(T, T)> p) {
    return std::upper_bound(this->begin(), this->end(), v, p) - this->begin();
  }
  int upper_bound(T const &v) {
    return std::upper_bound(this->begin(), this->end(), v) - this->begin();
  }

  int find_nearest(T const &v) {
    int i = this->lower_bound(v);
    if (i >= sz()) {
      --i;
    } else if ((*this)[i] != v) {
      int p = i - 1;
      if (p >= 0) {
        int id = abs((*this)[i] - v);
        int pd = abs((*this)[p] - v);
        if (pd < id) {
          i = p;
        }
      }
    }
    return i;
  }

  // 見つからなければ-1
  int find(T const &v) {
    int i = this->lower_bound(v);
    if (i >= sz()) {
      return -1;
    }
    if ((*this)[i] != v) {
      return -1;
    }
    return i;
  }
};
using ints = arr<ll>;

template <class T> struct que : public queue<T> {
  ll sz() const { return (ll)this->size(); }
  T popfront() {
    T v = this->front();
    this->pop();
    return v;
  }
};

template <class A, class B> struct pr {
  union {
    A a;
    A key;
    A first;
    A x;
  };
  union {
    B b;
    B value;
    B second;
    B y;
  };

  pr() : a(A()), b(B()){};
  pr(A a_, B b_) : a(a_), b(b_) {}
  pr(pr const &r) : a(r.a), b(r.b){};
  pr(pair<A, B> const &r) : a(r.first), b(r.second){};

  bool operator==(pr const &r) const { return a == r.a && b == r.b; }
  bool operator!=(pr const &r) const { return !((*this) == r); }
  bool operator<(pr const &r) const {
    if (a == r.a) {
      return b < r.b;
    }
    return a < r.a;
  }

  pr operator+(pr v) const { return pr(x, y) += v; }
  pr operator-(pr v) const { return pr(x, y) -= v; }

  pr &operator+=(pr v) {
    x += v.x;
    y += v.y;
    return *this;
  }
  pr &operator-=(pr v) {
    x -= v.x;
    y -= v.y;
    return *this;
  }

  void flip() { swap(x, y); }

  friend istream &operator>>(istream &is, pr &p) {
    is >> p.a >> p.b;
    return is;
  }
  friend ostream &operator<<(ostream &os, pr const &p) {
    os << p.a << " " << p.b;
    return os;
  }
};
using pint = pr<ll, ll>;
using pints = arr<pint>;

template <class A, class B, class C> struct tr {
  union {
    A a;
    A first;
    A x;
  };
  union {
    B b;
    B second;
    B y;
  };
  union {
    C c;
    C third;
    C z;
  };

  tr() : a(A()), b(B()), c(C()){};
  tr(A a_, B b_, C c_) : a(a_), b(b_), c(c_) {}
  tr(tr const &r) : a(r.a), b(r.b), c(r.c){};

  bool operator==(tr const &r) const {
    return a == r.a && b == r.b && c == r.c;
  }
  bool operator!=(tr const &r) const { return !((*this) == r); }
  bool operator<(tr const &r) const {
    if (a == r.a) {
      if (b == r.b) {
        return c < r.c;
      }
      return b < r.b;
    }
    return a < r.a;
  }

  tr operator+(tr v) const { return tr(x, y, z) += v; }
  tr operator-(tr v) const { return tr(x, y, z) -= v; }

  tr &operator+=(tr v) {
    x += v.x;
    y += v.y;
    z += v.z;
    return *this;
  }
  tr &operator-=(tr v) {
    x -= v.x;
    y -= v.y;
    z -= v.z;
    return *this;
  }

  friend istream &operator>>(istream &is, tr &p) {
    is >> p.a >> p.b >> p.c;
    return is;
  }
  friend ostream &operator<<(ostream &os, tr const &p) {
    os << p.a << " " << p.b << " " << p.c;
    return os;
  }
};
using tint = tr<ll, ll, ll>;
using tints = arr<tint>;

template <class K, class V> struct dic : public map<K, V> {
  bool get(K const &k, V *v) {
    auto it = this->find(k);
    if (it != this->end()) {
      *v = it->second;
      return true;
    }
    return false;
  }
};

template <class T> struct arr2 {
  vector<vector<T>> m_vec;
  int m_width;
  int m_height;

  arr2() : m_width(0), m_height(0) {}
  arr2(int w, int h, T const &value = T()) : m_width(w), m_height(h) {
    m_vec.resize(h, vector<T>(w, value));
  }
  arr2(arr2 const &r) {
    m_vec = r.m_vec;
    m_width = r.m_width;
    m_height = r.m_height;
  }
  arr2(arr2 &&r) {
    m_vec = move(r.m_vec);
    m_width = r.m_width;
    m_height = r.m_height;
  }
  arr2 &operator=(arr2 const &r) {
    m_vec = r.m_vec;
    m_width = r.m_width;
    m_height = r.m_height;
    return *this;
  }
  arr2 &operator=(arr2 &&r) {
    m_vec = move(r.m_vec);
    m_width = r.m_width;
    m_height = r.m_height;
    return *this;
  }

  bool operator==(arr2 const &r) const { return m_vec = r.m_vec; }

  bool operator<(arr2 const &r) const {
    if (m_width != r.m_width) {
      return m_width < r.m_width;
    }
    if (m_height != r.m_height) {
      return m_height < r.m_height;
    }
    REP(y, m_height) {
      REP(x, m_width) {
        if ((*this)(x, y) != r(x, y)) {
          return (*this)(x, y) < r(x, y);
        }
      }
    }
    return false;
  }

  pint size() const { return pint(m_width, m_height); }
  int width() const { return m_width; }
  int height() const { return m_height; }

  void init(int w, int h, T const &value = T()) {
    m_vec.clear();
    m_vec.resize(h, vector<T>(w, value));
    m_width = w;
    m_height = h;
  }
  void init(pint size, T const &value = T()) { init(size.x, size.y, value); }
  T &operator()(int x, int y) { return m_vec[y][x]; }
  T const &operator()(int x, int y) const { return m_vec[y][x]; }

  T &operator()(pint p) { return m_vec[p.y][p.x]; }
  T const &operator()(pint p) const { return m_vec[p.y][p.x]; }

  T &operator[](pint p) { return m_vec[p.y][p.x]; }
  T const &operator[](pint p) const { return m_vec[p.y][p.x]; }

  bool isIn(int x, int y) const {
    return x >= 0 && x < m_width && y >= 0 && y < m_height;
  }
  bool isIn(pint p) const { return isIn(p.x, p.y); }
  bool isOut(int x, int y) const {
    return x < 0 || x >= m_width || y < 0 || y >= m_height;
  }
  bool isOut(pint p) const { return isOut(p.x, p.y); }

  struct iterator {
  private:
    arr2<T> *owner;

  public:
    pint pt;

    iterator(arr2<T> *owner_, pint pt_) : owner(owner_), pt(pt_) {}

    bool operator==(iterator const &r) const { return pt == r.pt; }
    bool operator!=(iterator const &r) const { return !((*this) == r); }
    void operator++() {
      ++pt.x;
      if (pt.x >= owner->width()) {
        ++pt.y;
        pt.x = 0;
      }
    }
    T &operator*() { return (*owner)(pt); }
  };
  iterator begin() { return iterator(this, pint(0, 0)); }
  iterator end() { return iterator(this, pint(0, height())); }

  void disp(ostream &os) {
    REP(y, m_height) {
      REP(x, m_width) { os << setw(2) << (*this)(x, y) << " "; }
      os << endl;
    }
    os << endl;
  }
};

const pints around4 = {pint(-1, 0), pint(0, -1), pint(1, 0), pint(0, 1)};

//------------------------------------------------------------
template <class T> void chmin(T &a, T b) {
  if (b < a) {
    a = b;
  }
}
template <class T> void chmax(T &a, T b) {
  if (b > a) {
    a = b;
  }
}

constexpr int gcd(int a, int b) {
  if (a < 0) {
    a = -a;
  }
  if (b < 0) {
    b = -b;
  }
  if (a == 0) {
    return b;
  }
  if (b == 0) {
    return a;
  }

  while (int c = a % b) {
    a = b;
    b = c;
  }
  return b;
}

constexpr int lcm(int a, int b) { return a / gcd(a, b) * b; }

//------------------------------------------------------------
template <int M> struct modint {
  int raw;

  modint() { raw = 0; }
  modint(int v) {
    if (v < 0) {
      raw = (v % M) + M;
    } else if (v >= M) {
      raw = v % M;
    } else {
      raw = v;
    }
  }
  modint operator+(modint v) const { return modint(raw) += v; }
  modint operator-(modint v) const { return modint(raw) -= v; }
  modint operator*(modint v) const { return modint(raw) *= v; }

  modint &operator+=(modint v) {
    raw += v.raw;
    if (raw >= M) {
      raw -= M;
    }
    return *this;
  }
  modint &operator-=(modint v) {
    raw -= v.raw;
    if (raw < 0) {
      raw += M;
    }
    return *this;
  }
  modint &operator*=(modint v) {
    raw = (raw * v.raw) % M;
    return *this;
  }
  modint pow(int n) const { return modint::pow(raw, n); }
  static modint pow(int a, int n) {
    if (n < 0) {
      // not support
      abort();
    }

    int r = 1;
    while (n) {
      if (n & 1) {
        r = (r * a) % M;
      }
      a = (a * a) % M;
      n >>= 1;
    }
    return modint(r);
  }

  modint inv() const {
    int a = raw;
    int b = M;
    int u = 1;
    int v = 0;
    while (b) {
      int t = a / b;
      a -= t * b;
      u -= t * v;
      swap(a, b);
      swap(u, v);
    }
    u %= M;
    if (u < 0) {
      u += M;
    }
    return u;
  }

  friend istream &operator>>(istream &is, modint &m) {
    int v;
    is >> v;
    m = modint(v);
    return is;
  }
  friend ostream &operator<<(ostream &os, modint const &m) {
    return os << m.raw;
  }
};
using mint = modint<MOD>;
using mints = arr<mint>;

//------------------------------------------------------------

struct OutputStream {
  template <class T>
  friend OutputStream &operator<<(OutputStream &s, T const &v) {
    mos << v << '\\n';
    return s;
  }
} out;

struct PrintStream {
  stringstream ss;

  template <class T> friend PrintStream &operator<<(PrintStream &s, T &&v) {
    s.ss << v << ' ';
    return s;
  }

  PrintStream &operator<<(PrintStream &(*manip)(PrintStream &)) {
    return (*manip)(*this);
  }
} prn;

PrintStream &endl(PrintStream &s) {
  string str = s.ss.str();
  s.ss = stringstream();
  if (str.empty() == false) {
    str.pop_back();
  }
  mos << str << '\\n';
  return s;
}

//------------------------------------------------------------
template <class T> void input(T &value) { mis >> value; }
void input(int &value, int add) {
  mis >> value;
  value += add;
}
template <class A, class B> void input(pr<A, B> &value) {
  mis >> value.a >> value.b;
}
template <class A, class B> void input(pr<A, B> &value, int addA, int addB) {
  mis >> value.a >> value.b;
  value.a += addA;
  value.b += addB;
}
template <class A, class B, class C> void input(tr<A, B, C> &value) {
  mis >> value.a >> value.b >> value.c;
}
template <class A, class B, class C>
void input(tr<A, B, C> &value, int addA, int addB, int addC) {
  mis >> value.a >> value.b >> value.c;
  value.a += addA;
  value.b += addB;
  value.c += addC;
}
template <class T, class... ARGS>
void input(arr<T> &value, int N, ARGS &&...args) {
  value.init(N);
  REP(i, N) { input(value[i], forward<ARGS>(args)...); }
}
template <class T, class... ARGS>
void input(arr2<T> &value, int H, int W, ARGS &&...args) {
  value.init(W, H);
  REP(y, H) {
    REP(x, W) { input(value(x, y), forward<ARGS>(args)...); }
  }
}
template <class K, class V, class... ARGS>
void input(dic<K, V> &value, int N, ARGS &&...args) {
  REP(i, N) {
    pair<K, V> pr;
    input(pr.first);
    input(pr.second, forward<ARGS>(args)...);
    value.insert(pr);
  }
}

template <class T> struct inputHolder {
  T value;
  template <class... ARGS> inputHolder(ARGS &&...args) {
    input(value, forward<ARGS>(args)...);
  }
  operator T() { return value; }
};

template <class T, class Tuple, size_t... Index>
T MakeFromTupleImpl(Tuple &&t, index_sequence<Index...>) {
  return T(get<Index>(forward<Tuple>(t))...);
}
template <class T, class Tuple> T MakeFromTuple(Tuple &&t) {
  return MakeFromTupleImpl<T>(
      forward<Tuple>(t),
      make_index_sequence<tuple_size<remove_reference_t<Tuple>>::value>{});
}
template <class... ARGS> struct inputWithParam {
  tuple<ARGS...> param;
  inputWithParam() {}
  explicit inputWithParam(tuple<ARGS...> &&param_) : param(param_) {}
  operator int() { return MakeFromTuple<inputHolder<int>>(param); }
  operator double() { return MakeFromTuple<inputHolder<double>>(param); }
  operator string() { return MakeFromTuple<inputHolder<string>>(param); }
  operator char() { return MakeFromTuple<inputHolder<char>>(param); }
  template <class A, class B> operator pr<A, B>() {
    return MakeFromTuple<inputHolder<pr<A, B>>>(param);
  }
  template <class A, class B, class C> operator tr<A, B, C>() {
    return MakeFromTuple<inputHolder<tr<A, B, C>>>(param);
  }
  template <class T> operator arr<T>() {
    return MakeFromTuple<inputHolder<arr<T>>>(param);
  }
  template <class A, class B> operator dic<A, B>() {
    return MakeFromTuple<inputHolder<dic<A, B>>>(param);
  }
  template <class T> operator arr2<T>() {
    return MakeFromTuple<inputHolder<arr2<T>>>(param);
  }
};
struct inputObject {
  operator int() { return inputWithParam<>(); }
  operator double() { return inputWithParam<>(); }
  operator string() { return inputWithParam<>(); }
  operator char() { return inputWithParam<>(); }
  template <class A, class B> operator pr<A, B>() { return inputWithParam<>(); }
  template <class A, class B, class C> operator tr<A, B, C>() {
    return inputWithParam<>();
  }
  template <class... ARGS> inputWithParam<ARGS...> operator()(ARGS &&...args) {
    inputWithParam<ARGS...> withParam(forward_as_tuple(args...));
    return withParam;
  }
} in;

//------------------------------------------------------------
#endif

struct MyMain {
  int N = in;

  void Run() {
    int ans = 0;
    FOR(c, 1, N) {
      int mm = (N - c);
      int m = sqrt(mm);

      int cnt = 0;
      FOR(a, 1, m + 1) {
        if ((mm / a) * a == mm) {
          cnt++;
        }
      }
      cnt *= 2;
      if (m * m == mm) {
        cnt--;
      }
      ans += cnt;
    }
    out << ans;
  }
};

#define MOD 1000000007
// #include <atcoder/all>

#if 1
//------------------------------------------------------------
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;

template <class T> struct Entry {
  static void Run() { T().Run(); }
};
struct MyMain;

#if defined(TEST)
#include "test.hpp"
extern istream &mis;
extern ostream &mos;
#else
istream &mis = cin;
ostream &mos = cout;
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(16);
  Entry<MyMain>::Run();
  return 0;
}
#endif

//------------------------------------------------------------
using ll = long long;
#define int ll

#define FOR(i, s, e) for (ll i = ll(s); i < ll(e); ++i)
#define RFOR(i, s, e) for (ll i = ll(e) - 1; i >= ll(s); --i)
#define REP(i, n) for (ll i = 0, i##_size = ll(n); i < i##_size; ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)

#define INF INT64_MAX

//------------------------------------------------------------
template <class T> struct arr : public vector<T> {
  arr() {}
  arr(initializer_list<T> il) : vector<T>(il) {}
  explicit arr(ll n, T v = T()) : vector<T>(n, v) {}

  T &operator()(int i) { return (*this)[i]; }
  T const &operator()(int i) const { return (*this)[i]; }
  void init(ll n, T v = T()) {
    this->clear();
    this->resize(n, v);
  }
  ll sz() const { return (ll)this->size(); }
  void pb(T v) { this->push_back(v); }
  void sort() { std::sort(this->begin(), this->end()); }
  void sort(function<bool(T, T)> p) {
    std::sort(this->begin(), this->end(), p);
  }
  void rsort() { std::sort(this->begin(), this->end(), greater<T>()); }
  void reverse() { std::reverse(this->begin(), this->end()); }
  void unique_erase() {
    this->erase(std::unique(this->begin(), this->end()), this->end());
  }
  bool next_permutation() {
    return std::next_permutation(this->begin(), this->end());
  }

  // これ以下はソート済み前提
  int lower_bound(T const &v, function<bool(T, T)> p) {
    return std::lower_bound(this->begin(), this->end(), v, p) - this->begin();
  }
  int lower_bound(T const &v) {
    return std::lower_bound(this->begin(), this->end(), v) - this->begin();
  }

  int upper_bound(T const &v, function<bool(T, T)> p) {
    return std::upper_bound(this->begin(), this->end(), v, p) - this->begin();
  }
  int upper_bound(T const &v) {
    return std::upper_bound(this->begin(), this->end(), v) - this->begin();
  }

  int find_nearest(T const &v) {
    int i = this->lower_bound(v);
    if (i >= sz()) {
      --i;
    } else if ((*this)[i] != v) {
      int p = i - 1;
      if (p >= 0) {
        int id = abs((*this)[i] - v);
        int pd = abs((*this)[p] - v);
        if (pd < id) {
          i = p;
        }
      }
    }
    return i;
  }

  // 見つからなければ-1
  int find(T const &v) {
    int i = this->lower_bound(v);
    if (i >= sz()) {
      return -1;
    }
    if ((*this)[i] != v) {
      return -1;
    }
    return i;
  }
};
using ints = arr<ll>;

template <class T> struct que : public queue<T> {
  ll sz() const { return (ll)this->size(); }
  T popfront() {
    T v = this->front();
    this->pop();
    return v;
  }
};

template <class A, class B> struct pr {
  union {
    A a;
    A key;
    A first;
    A x;
  };
  union {
    B b;
    B value;
    B second;
    B y;
  };

  pr() : a(A()), b(B()){};
  pr(A a_, B b_) : a(a_), b(b_) {}
  pr(pr const &r) : a(r.a), b(r.b){};
  pr(pair<A, B> const &r) : a(r.first), b(r.second){};

  bool operator==(pr const &r) const { return a == r.a && b == r.b; }
  bool operator!=(pr const &r) const { return !((*this) == r); }
  bool operator<(pr const &r) const {
    if (a == r.a) {
      return b < r.b;
    }
    return a < r.a;
  }

  pr operator+(pr v) const { return pr(x, y) += v; }
  pr operator-(pr v) const { return pr(x, y) -= v; }

  pr &operator+=(pr v) {
    x += v.x;
    y += v.y;
    return *this;
  }
  pr &operator-=(pr v) {
    x -= v.x;
    y -= v.y;
    return *this;
  }

  void flip() { swap(x, y); }

  friend istream &operator>>(istream &is, pr &p) {
    is >> p.a >> p.b;
    return is;
  }
  friend ostream &operator<<(ostream &os, pr const &p) {
    os << p.a << " " << p.b;
    return os;
  }
};
using pint = pr<ll, ll>;
using pints = arr<pint>;

template <class A, class B, class C> struct tr {
  union {
    A a;
    A first;
    A x;
  };
  union {
    B b;
    B second;
    B y;
  };
  union {
    C c;
    C third;
    C z;
  };

  tr() : a(A()), b(B()), c(C()){};
  tr(A a_, B b_, C c_) : a(a_), b(b_), c(c_) {}
  tr(tr const &r) : a(r.a), b(r.b), c(r.c){};

  bool operator==(tr const &r) const {
    return a == r.a && b == r.b && c == r.c;
  }
  bool operator!=(tr const &r) const { return !((*this) == r); }
  bool operator<(tr const &r) const {
    if (a == r.a) {
      if (b == r.b) {
        return c < r.c;
      }
      return b < r.b;
    }
    return a < r.a;
  }

  tr operator+(tr v) const { return tr(x, y, z) += v; }
  tr operator-(tr v) const { return tr(x, y, z) -= v; }

  tr &operator+=(tr v) {
    x += v.x;
    y += v.y;
    z += v.z;
    return *this;
  }
  tr &operator-=(tr v) {
    x -= v.x;
    y -= v.y;
    z -= v.z;
    return *this;
  }

  friend istream &operator>>(istream &is, tr &p) {
    is >> p.a >> p.b >> p.c;
    return is;
  }
  friend ostream &operator<<(ostream &os, tr const &p) {
    os << p.a << " " << p.b << " " << p.c;
    return os;
  }
};
using tint = tr<ll, ll, ll>;
using tints = arr<tint>;

template <class K, class V> struct dic : public map<K, V> {
  bool get(K const &k, V *v) {
    auto it = this->find(k);
    if (it != this->end()) {
      *v = it->second;
      return true;
    }
    return false;
  }
};

template <class T> struct arr2 {
  vector<vector<T>> m_vec;
  int m_width;
  int m_height;

  arr2() : m_width(0), m_height(0) {}
  arr2(int w, int h, T const &value = T()) : m_width(w), m_height(h) {
    m_vec.resize(h, vector<T>(w, value));
  }
  arr2(arr2 const &r) {
    m_vec = r.m_vec;
    m_width = r.m_width;
    m_height = r.m_height;
  }
  arr2(arr2 &&r) {
    m_vec = move(r.m_vec);
    m_width = r.m_width;
    m_height = r.m_height;
  }
  arr2 &operator=(arr2 const &r) {
    m_vec = r.m_vec;
    m_width = r.m_width;
    m_height = r.m_height;
    return *this;
  }
  arr2 &operator=(arr2 &&r) {
    m_vec = move(r.m_vec);
    m_width = r.m_width;
    m_height = r.m_height;
    return *this;
  }

  bool operator==(arr2 const &r) const { return m_vec = r.m_vec; }

  bool operator<(arr2 const &r) const {
    if (m_width != r.m_width) {
      return m_width < r.m_width;
    }
    if (m_height != r.m_height) {
      return m_height < r.m_height;
    }
    REP(y, m_height) {
      REP(x, m_width) {
        if ((*this)(x, y) != r(x, y)) {
          return (*this)(x, y) < r(x, y);
        }
      }
    }
    return false;
  }

  pint size() const { return pint(m_width, m_height); }
  int width() const { return m_width; }
  int height() const { return m_height; }

  void init(int w, int h, T const &value = T()) {
    m_vec.clear();
    m_vec.resize(h, vector<T>(w, value));
    m_width = w;
    m_height = h;
  }
  void init(pint size, T const &value = T()) { init(size.x, size.y, value); }
  T &operator()(int x, int y) { return m_vec[y][x]; }
  T const &operator()(int x, int y) const { return m_vec[y][x]; }

  T &operator()(pint p) { return m_vec[p.y][p.x]; }
  T const &operator()(pint p) const { return m_vec[p.y][p.x]; }

  T &operator[](pint p) { return m_vec[p.y][p.x]; }
  T const &operator[](pint p) const { return m_vec[p.y][p.x]; }

  bool isIn(int x, int y) const {
    return x >= 0 && x < m_width && y >= 0 && y < m_height;
  }
  bool isIn(pint p) const { return isIn(p.x, p.y); }
  bool isOut(int x, int y) const {
    return x < 0 || x >= m_width || y < 0 || y >= m_height;
  }
  bool isOut(pint p) const { return isOut(p.x, p.y); }

  struct iterator {
  private:
    arr2<T> *owner;

  public:
    pint pt;

    iterator(arr2<T> *owner_, pint pt_) : owner(owner_), pt(pt_) {}

    bool operator==(iterator const &r) const { return pt == r.pt; }
    bool operator!=(iterator const &r) const { return !((*this) == r); }
    void operator++() {
      ++pt.x;
      if (pt.x >= owner->width()) {
        ++pt.y;
        pt.x = 0;
      }
    }
    T &operator*() { return (*owner)(pt); }
  };
  iterator begin() { return iterator(this, pint(0, 0)); }
  iterator end() { return iterator(this, pint(0, height())); }

  void disp(ostream &os) {
    REP(y, m_height) {
      REP(x, m_width) { os << setw(2) << (*this)(x, y) << " "; }
      os << endl;
    }
    os << endl;
  }
};

const pints around4 = {pint(-1, 0), pint(0, -1), pint(1, 0), pint(0, 1)};

//------------------------------------------------------------
template <class T> void chmin(T &a, T b) {
  if (b < a) {
    a = b;
  }
}
template <class T> void chmax(T &a, T b) {
  if (b > a) {
    a = b;
  }
}

constexpr int gcd(int a, int b) {
  if (a < 0) {
    a = -a;
  }
  if (b < 0) {
    b = -b;
  }
  if (a == 0) {
    return b;
  }
  if (b == 0) {
    return a;
  }

  while (int c = a % b) {
    a = b;
    b = c;
  }
  return b;
}

constexpr int lcm(int a, int b) { return a / gcd(a, b) * b; }

//------------------------------------------------------------
template <int M> struct modint {
  int raw;

  modint() { raw = 0; }
  modint(int v) {
    if (v < 0) {
      raw = (v % M) + M;
    } else if (v >= M) {
      raw = v % M;
    } else {
      raw = v;
    }
  }
  modint operator+(modint v) const { return modint(raw) += v; }
  modint operator-(modint v) const { return modint(raw) -= v; }
  modint operator*(modint v) const { return modint(raw) *= v; }

  modint &operator+=(modint v) {
    raw += v.raw;
    if (raw >= M) {
      raw -= M;
    }
    return *this;
  }
  modint &operator-=(modint v) {
    raw -= v.raw;
    if (raw < 0) {
      raw += M;
    }
    return *this;
  }
  modint &operator*=(modint v) {
    raw = (raw * v.raw) % M;
    return *this;
  }
  modint pow(int n) const { return modint::pow(raw, n); }
  static modint pow(int a, int n) {
    if (n < 0) {
      // not support
      abort();
    }

    int r = 1;
    while (n) {
      if (n & 1) {
        r = (r * a) % M;
      }
      a = (a * a) % M;
      n >>= 1;
    }
    return modint(r);
  }

  modint inv() const {
    int a = raw;
    int b = M;
    int u = 1;
    int v = 0;
    while (b) {
      int t = a / b;
      a -= t * b;
      u -= t * v;
      swap(a, b);
      swap(u, v);
    }
    u %= M;
    if (u < 0) {
      u += M;
    }
    return u;
  }

  friend istream &operator>>(istream &is, modint &m) {
    int v;
    is >> v;
    m = modint(v);
    return is;
  }
  friend ostream &operator<<(ostream &os, modint const &m) {
    return os << m.raw;
  }
};
using mint = modint<MOD>;
using mints = arr<mint>;

//------------------------------------------------------------

struct OutputStream {
  template <class T>
  friend OutputStream &operator<<(OutputStream &s, T const &v) {
    mos << v << '\\n';
    return s;
  }
} out;

struct PrintStream {
  stringstream ss;

  template <class T> friend PrintStream &operator<<(PrintStream &s, T &&v) {
    s.ss << v << ' ';
    return s;
  }

  PrintStream &operator<<(PrintStream &(*manip)(PrintStream &)) {
    return (*manip)(*this);
  }
} prn;

PrintStream &endl(PrintStream &s) {
  string str = s.ss.str();
  s.ss = stringstream();
  if (str.empty() == false) {
    str.pop_back();
  }
  mos << str << '\\n';
  return s;
}

//------------------------------------------------------------
template <class T> void input(T &value) { mis >> value; }
void input(int &value, int add) {
  mis >> value;
  value += add;
}
template <class A, class B> void input(pr<A, B> &value) {
  mis >> value.a >> value.b;
}
template <class A, class B> void input(pr<A, B> &value, int addA, int addB) {
  mis >> value.a >> value.b;
  value.a += addA;
  value.b += addB;
}
template <class A, class B, class C> void input(tr<A, B, C> &value) {
  mis >> value.a >> value.b >> value.c;
}
template <class A, class B, class C>
void input(tr<A, B, C> &value, int addA, int addB, int addC) {
  mis >> value.a >> value.b >> value.c;
  value.a += addA;
  value.b += addB;
  value.c += addC;
}
template <class T, class... ARGS>
void input(arr<T> &value, int N, ARGS &&...args) {
  value.init(N);
  REP(i, N) { input(value[i], forward<ARGS>(args)...); }
}
template <class T, class... ARGS>
void input(arr2<T> &value, int H, int W, ARGS &&...args) {
  value.init(W, H);
  REP(y, H) {
    REP(x, W) { input(value(x, y), forward<ARGS>(args)...); }
  }
}
template <class K, class V, class... ARGS>
void input(dic<K, V> &value, int N, ARGS &&...args) {
  REP(i, N) {
    pair<K, V> pr;
    input(pr.first);
    input(pr.second, forward<ARGS>(args)...);
    value.insert(pr);
  }
}

template <class T> struct inputHolder {
  T value;
  template <class... ARGS> inputHolder(ARGS &&...args) {
    input(value, forward<ARGS>(args)...);
  }
  operator T() { return value; }
};

template <class T, class Tuple, size_t... Index>
T MakeFromTupleImpl(Tuple &&t, index_sequence<Index...>) {
  return T(get<Index>(forward<Tuple>(t))...);
}
template <class T, class Tuple> T MakeFromTuple(Tuple &&t) {
  return MakeFromTupleImpl<T>(
      forward<Tuple>(t),
      make_index_sequence<tuple_size<remove_reference_t<Tuple>>::value>{});
}
template <class... ARGS> struct inputWithParam {
  tuple<ARGS...> param;
  inputWithParam() {}
  explicit inputWithParam(tuple<ARGS...> &&param_) : param(param_) {}
  operator int() { return MakeFromTuple<inputHolder<int>>(param); }
  operator double() { return MakeFromTuple<inputHolder<double>>(param); }
  operator string() { return MakeFromTuple<inputHolder<string>>(param); }
  operator char() { return MakeFromTuple<inputHolder<char>>(param); }
  template <class A, class B> operator pr<A, B>() {
    return MakeFromTuple<inputHolder<pr<A, B>>>(param);
  }
  template <class A, class B, class C> operator tr<A, B, C>() {
    return MakeFromTuple<inputHolder<tr<A, B, C>>>(param);
  }
  template <class T> operator arr<T>() {
    return MakeFromTuple<inputHolder<arr<T>>>(param);
  }
  template <class A, class B> operator dic<A, B>() {
    return MakeFromTuple<inputHolder<dic<A, B>>>(param);
  }
  template <class T> operator arr2<T>() {
    return MakeFromTuple<inputHolder<arr2<T>>>(param);
  }
};
struct inputObject {
  operator int() { return inputWithParam<>(); }
  operator double() { return inputWithParam<>(); }
  operator string() { return inputWithParam<>(); }
  operator char() { return inputWithParam<>(); }
  template <class A, class B> operator pr<A, B>() { return inputWithParam<>(); }
  template <class A, class B, class C> operator tr<A, B, C>() {
    return inputWithParam<>();
  }
  template <class... ARGS> inputWithParam<ARGS...> operator()(ARGS &&...args) {
    inputWithParam<ARGS...> withParam(forward_as_tuple(args...));
    return withParam;
  }
} in;

//------------------------------------------------------------
#endif

struct MyMain {
  int N = in;

  void Run() {
    int ans = 0;
    FOR(a, 1, N) {
      int b = N / a;
      ans += b;
      if (b * a == N) {
        ans--;
      }
    }
    out << ans;
  }
};


#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

vector<long long> enum_divisors(long long N) {
  vector<long long> res;
  for (long long i = 1; i * i <= N; ++i) {
    if (N % i == 0) {
      res.push_back(i);
      // 重複しないならば i の相方である N/i も push
      if (N / i != i)
        res.push_back(N / i);
    }
  }
  return res;
}

int main() {
  long long N;
  cin >> N;
  long long sum = 0;
  for (int k = 1; k < N; k++) {
    const auto &res = enum_divisors(k);
    sum = sum + res.size();
  }
  cout << sum << endl;
}

#include <iostream>
#include <vector>
using namespace std;

vector<pair<long long, long long>> prime_factorize(long long N) {
  vector<pair<long long, long long>> res;
  for (long long a = 2; a * a <= N; ++a) {
    if (N % a != 0)
      continue;
    long long ex = 0;
    while (N % a == 0) {
      ++ex;
      N /= a;
    }
    res.push_back({a, ex});
  }
  if (N != 1)
    res.push_back({N, 1});
  return res;
}

int main() {
  long long N;
  cin >> N;
  int sum = 0;
  for (int i = 1; i < N; i++) {
    const auto &pf = prime_factorize(i);
    long long res = 1;
    for (auto p : pf)
      res *= p.second + 1;
    sum = sum + res;
  }
  cout << sum << endl;
}


#include <bits/stdc++.h>
using namespace std;
int wy(long long int n) {
  int m, y, t = 0;
  for (int i = 1; i <= n + 1; i++) {
    if (i * i > n) {
      return t;
    } else if (n % i == 0)
      if (i * i == n) {
        t++;
      } else
        t = t + 2;
  }
}
int main() {
  int k, mas = 0;
  scanf("%d", &k);
  for (int p = 1; p < k; p++)
    mas = wy(p) + mas;
  printf("%d", mas);
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, k = 1, m = 0;
  scanf("%d", &n);
  while (k * k < n) {
    m = (n / k - k) * 2 + m + 1;
    if (n % k == 0)
      m -= 2;
    k++;
  }

  printf("%d", m);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int n, ans = 1;
bool p[maxn];
vector<int> v;
vector<int>::iterator it;
void check(int k) {
  int result = 1;
  if (p[k]) {
    ans += 2;
    return;
  }
  for (it = v.begin(); it != v.end(); it++) {
    if ((*it) > k)
      break;
    if (k % (*it) == 0) {
      int temp = 0;
      while (k % (*it) == 0 && k > 0) {
        k /= (*it);
        temp++;
      }
      result *= (temp + 1);
    }
  }
  ans += result;
  return;
}
int main() {
  cin >> n;
  memset(p, true, sizeof(p));
  for (int i = 2; i <= sqrt(n); i++)
    if (p[i] == 1)
      for (int j = i + i; j <= n; j += i)
        p[j] = 0;
  for (int i = 2; i <= n; i++)
    if (p[i])
      v.push_back(i);
  for (int i = 2; i < n; i++)
    check(i);
  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int n, ans;
int main() {
  cin >> n;
  for (int i = 1; i <= n; i++)
    for (int j = 1; j <= n; j++) {
      if (i * j >= n)
        break;
      else
        ans++;
    }
  cout << ans << endl;
  return 0;
}


#include <iostream>
#include <math.h>
#include <vector>

using namespace std;

int main() {
  int N;
  cin >> N;
  int ans = 0;
  for (int i = 1; i < N; i++) {
    int n = N - i;
    for (int j = 1; j <= sqrt(n); j++) {
      if (n % j == 0) {
        ans += 2;
      }
    }
    if (sqrt(n) == floor(sqrt(n))) {
      ans--;
    }
  }
  cout << ans << endl;
  return 0;
}

#include <iostream>
#include <math.h>
#include <vector>

using namespace std;

int main() {
  int N;
  cin >> N;
  int ans = 0;
  for (int i = 1; i <= N - 1; i++) {
    ans += (N - 1) / i;
  }
  cout << ans << endl;
  return 0;
}


#include <iostream>
#include <map>
using namespace std;

// 素因数分解
template <typename T> map<T, T> prime_factor(T n) {
  map<T, T> ret;
  for (T i = 2; i * i <= n; i++) {
    T tmp = 0;
    while (n % i == 0) {
      tmp++;
      n /= i;
    }
    ret[i] = tmp;
  }
  if (n != 1)
    ret[n] = 1;
  return ret;
}
/*  divisor_num(n)
    入力：整数 n
    出力：nの約数の個数
    計算量：O(√n)
*/
template <typename T> T divisor_num(T N) {
  map<T, T> pf = prime_factor(N);
  T ret = 1;
  for (auto p : pf) {
    ret *= (p.second + 1);
  }
  return ret;
}
/*

int yakusu(int N){
    int res = 0;
    for (long long i = 1; i * i <= N; ++i) {
        if (N % i == 0) {
            res++;
            // 重複しないならば i の相方である N/i も push
            if (N/i != i) res++;
        }
    }
    // 小さい順に並び替える
    return res;
}

int  memo[1000000 + 10] = {0};

int yakusu2(int N){
    if(memo[N] == 0){

    }
    else{
        return memo[N];
    }
}
*/

int main() {
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; i++) {
    // int y = yakusu(n - i);
    long long y = divisor_num(n - i);
    // printf("%d + %d(%lld通り)\\n", i, n - i, y);
    ans += y;
  }

  cout << ans << endl;

  return 0;
}

#include <iostream>
using namespace std;

int main() {
  int n, ans = 0;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    ans += (n - 1) / i;
  }
  cout << ans << endl;
  return 0;
}


// nb_9960
#include <bits/stdc++.h>
using namespace std;
#define fi(i, a, n) for (ll i = a; i < n; i++)
#define ll long long
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
typedef vector<pl> vpii;
#define sz(a) int((a).size())
#define tr(c, i) for (typeof(c).begin() i = c.begin(); i != c.end(); i++)
#define present(c, x) (c.find(x) != c.end())
#define cpresent(c, x) (find(all(c), x) != c.end())
#define MOD 1000000007
#define PI 3.1415926536

void SieveOfEratosthenes(ll n, bool prime[], bool primesquare[], ll a[]) {
  // Create a boolean array "prime[0..n]" and
  // initialize all entries it as true. A value
  // in prime[i] will finally be false if i is
  // Not a prime, else true.
  for (ll i = 2; i <= n; i++)
    prime[i] = true;

  // Create a boolean array "primesquare[0..n*n+1]"
  // and initialize all entries it as false. A value
  // in squareprime[i] will finally be true if i is
  // square of prime, else false.
  for (ll i = 0; i <= (n * n + 1); i++)
    primesquare[i] = false;

  // 1 is not a prime number
  prime[1] = false;

  for (ll p = 2; p * p <= n; p++) {
    // If prime[p] is not changed, then
    // it is a prime
    if (prime[p] == true) {
      // Update all multiples of p
      for (ll i = p * 2; i <= n; i += p)
        prime[i] = false;
    }
  }

  ll j = 0;
  for (ll p = 2; p <= n; p++) {
    if (prime[p]) {
      // Storing primes in an array
      a[j] = p;

      // Update value in primesquare[p*p],
      // if p is prime.
      primesquare[p * p] = true;
      j++;
    }
  }
}

// Function to count divisors
ll countDivisors(ll n) {
  // If number is 1, then it will have only 1
  // as a factor. So, total factors will be 1.
  if (n == 1)
    return 1;

  bool prime[n + 1], primesquare[n * n + 1];

  ll a[n]; // for storing primes upto n

  // Calling SieveOfEratosthenes to store prime
  // factors of n and to store square of prime
  // factors of n
  SieveOfEratosthenes(n, prime, primesquare, a);

  // ans will contain total number of distinct
  // divisors
  ll ans = 1;

  // Loop for counting factors of n
  for (ll i = 0;; i++) {
    // a[i] is not less than cube root n
    if (a[i] * a[i] * a[i] > n)
      break;

    // Calculating power of a[i] in n.
    int cnt = 1;          // cnt is power of prime a[i] in n.
    while (n % a[i] == 0) // if a[i] is a factor of n
    {
      n = n / a[i];
      cnt = cnt + 1; // incrementing power
    }

    // Calculating the number of divisors
    // If n = a^p * b^q then total divisors of n
    // are (p+1)*(q+1)
    ans = ans * cnt;
  }

  // if a[i] is greater than cube root of n

  // First case
  if (prime[n])
    ans = ans * 2;

  // Second case
  else if (primesquare[n])
    ans = ans * 3;

  // Third case
  else if (n != 1)
    ans = ans * 4;

  return ans; // Total divisors
}

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  ll t = 1;
  // cin >> t;

  while (t--) {
    ll n;
    cin >> n;
    ll c = n - 1, cnt = 0, m = n - c;
    while (m <= (n - 1)) {
      cnt += countDivisors(m);
      m++;
    }
    cout << cnt << endl;
  }
  return 0;
}

// nb_9960
#include <bits/stdc++.h>
using namespace std;
#define fi(i, a, n) for (ll i = a; i < n; i++)
#define ll long long
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
typedef pair<ll, ll> pl;
typedef vector<ll> vl;
typedef vector<pl> vpii;
#define sz(a) int((a).size())
#define tr(c, i) for (typeof(c).begin() i = c.begin(); i != c.end(); i++)
#define present(c, x) (c.find(x) != c.end())
#define cpresent(c, x) (find(all(c), x) != c.end())
#define MOD 1000000007
#define PI 3.1415926536

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  ll t = 1;
  // cin >> t;

  while (t--) {
    ll n;
    cin >> n;
    ll cnt = 0;
    for (ll a = 1; a < n; a++) {
      for (ll b = 1; b < n; b++) {
        if (a * b >= n) {
          break;
        } else
          cnt++;
      }
    }
    cout << cnt << endl;
  }
  return 0;
}


#pragma GCC optimize(2)
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#define File(x) freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout);
#define re register
#define ri re int
#define gtch()                                                                 \\
  (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)     \\
       ? EOF                                                                   \\
       : *p1++)
#define For(i, a, b) for (ri i = a; i <= b; ++i)
#define iFor(i, a, b) for (ri i = a; i >= b; --i)
using namespace std;
typedef long long ll;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline ll fr() {
  re char ch = getchar();
  re ll res = 0;
  int bl = 0;
  while (!isdigit(ch))
    bl = (ch == '-'), ch = getchar();
  while (isdigit(ch))
    res = (res << 1) + (res << 3) + ch - '0', ch = getchar();
  return bl ? -res : res;
}
const int MAXN = 1e7;
int mf[MAXN];
ll prime[MAXN], tot;
ll d[MAXN], cnt[MAXN];
int n;
inline void sieve() {
  d[1] = 1;
  for (ri i = 2; i <= n; ++i) {
    if (!mf[i]) {
      mf[i] = i, prime[++tot] = i, d[i] = 2, cnt[i] = 1;
    }
    //		cout<<i<<" "<<d[i]<<" "<<cnt[i]<<"\\n";
    for (ri j = 1; j <= tot; ++j) {
      ri p = prime[j], t = i * p;
      mf[t] = p;
      if (p == mf[i]) {
        cnt[t] = cnt[i] + 1, d[t] = d[i] / (cnt[i] + 1) * (cnt[i] + 2);
        break;
      }
      cnt[t] = 1, d[t] = d[i] * 2;
    }
  }
}
signed main() {
  //	File("temp")
  n = fr();
  sieve();
  ll ans = 0;
  for (ri i = 1; i < n; ++i)
    ans += d[i];
  cout << ans;
  return 0;
}

#pragma GCC optimize(2)
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#define File(x) freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout);
#define re register
#define ri re int
#define gtch()                                                                 \\
  (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)     \\
       ? EOF                                                                   \\
       : *p1++)
#define For(i, a, b) for (ri i = a; i <= b; ++i)
#define iFor(i, a, b) for (ri i = a; i >= b; --i)
using namespace std;
typedef long long ll;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline ll fr() {
  re char ch = getchar();
  re ll res = 0;
  int bl = 0;
  while (!isdigit(ch))
    bl = (ch == '-'), ch = getchar();
  while (isdigit(ch))
    res = (res << 1) + (res << 3) + ch - '0', ch = getchar();
  return bl ? -res : res;
}
const int MAXN = 1e7;
int mf[MAXN];
ll prime[MAXN], tot;
ll d[MAXN], cnt[MAXN];
int n;
inline void sieve() {
  d[1] = 1;
  for (ri i = 2; i <= n; ++i) {
    if (!mf[i]) {
      mf[i] = i, prime[++tot] = i, d[i] = 2, cnt[i] = 1;
    }
    //		cout<<i<<" "<<d[i]<<" "<<cnt[i]<<"\\n";
    for (ri j = 1; j <= tot; ++j) {
      ri p = prime[j], t = i * p;
      if (t > n)
        break;
      mf[t] = p;
      if (p == mf[i]) {
        cnt[t] = cnt[i] + 1, d[t] = d[i] / (cnt[i] + 1) * (cnt[i] + 2);
        break;
      }
      cnt[t] = 1, d[t] = d[i] * 2;
    }
  }
}
signed main() {
  //	File("temp")
  n = fr();
  sieve();
  ll ans = 0;
  for (ri i = 1; i < n; ++i)
    ans += d[i];
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>

#define Rushia_mywife                                                          \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);
#define rep(i, head, n) for (int i = (head); i < n; i++)
#define F first
#define S second
#define FF first.first
#define FS first.second
#define SF second.first
#define SS second.second
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define all(x) (x).begin(), (x).end()
#define SZ(x) (int)(x).size()
#define mem(x, i) memset((x), (i), sizeof((x)))
#define odd(x) ((x)&1)
#define LG(x) (int)log2((x))

using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using ld = long double;

mt19937 mt_rand(time(0));
const int mod = 1000000007;
const int hnum = 998244353;
const ld PI = acos(-1);

#define int long long
int qpow(int x, int powcnt, int tomod) {
  int res = 1;
  for (; powcnt; powcnt >>= 1, x = (x * x) % tomod)
    if (1 & powcnt)
      res = (res * x) % tomod;
  return (res % tomod);
}
int gcd(int aaa, int bbb) { return (bbb == 0 ? aaa : gcd(bbb, aaa % bbb)); }
int lcm(int aaa, int bbb) { return (aaa / gcd(aaa, bbb)) * bbb; }
int C(int x) { return x * (x - 1) / 2; }
// --------------------------------------**

int n;

void solve() {
  cin >> n;
  n--;
  int ans = 0;
  while (n > 0) {
    int sum = 0;
    for (int i = 1; i * i <= n; i++) {
      if (n % i == 0) {
        sum += (i * i == n ? 1 : 2);
      }
    }
    ans += sum;
    n--;
  }
  cout << ans << '\\n';
}

signed main() {
  Rushia_mywife
  // int t; cin >> t;
  // while(t--)
  solve();
}

#include <bits/stdc++.h>

#define Rushia_mywife                                                          \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);
#define rep(i, head, n) for (int i = (head); i < n; i++)
#define F first
#define S second
#define FF first.first
#define FS first.second
#define SF second.first
#define SS second.second
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define all(x) (x).begin(), (x).end()
#define SZ(x) (int)(x).size()
#define mem(x, i) memset((x), (i), sizeof((x)))
#define odd(x) ((x)&1)
#define LG(x) (int)log2((x))

using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using ld = long double;

mt19937 mt_rand(time(0));
const int mod = 1000000007;
const int hnum = 998244353;
const ld PI = acos(-1);

#define int long long
int qpow(int x, int powcnt, int tomod) {
  int res = 1;
  for (; powcnt; powcnt >>= 1, x = (x * x) % tomod)
    if (1 & powcnt)
      res = (res * x) % tomod;
  return (res % tomod);
}
int gcd(int aaa, int bbb) { return (bbb == 0 ? aaa : gcd(bbb, aaa % bbb)); }
int lcm(int aaa, int bbb) { return (aaa / gcd(aaa, bbb)) * bbb; }
int C(int x) { return x * (x - 1) / 2; }
// --------------------------------------**

int n;

void solve() {
  cin >> n;
  int ans = 0;
  /*
  while(n>0){
          int sum = 0;
          for(int i=1;i*i<=n;i++){
                  if(n%i==0){
                          sum += (i*i==n ? 1 : 2);
                  }
          }
          ans += sum;
          n--;
  }
  */
  n--;
  for (int i = 1; i <= n; i++) {
    // if(i*i<=n)
    // ans--;
    ans += (n / i);
    // cout << i << " : " << ans << '\\n';
  }
  cout << ans << '\\n';
}

signed main() {
  Rushia_mywife
  // int t; cin >> t;
  // while(t--)
  solve();
}


#pragma GCC optimize("Ofast")
#include "bits/stdc++.h"

// Begin Header {{{
using namespace std;

#ifndef DEBUG
#define dump(...)
#endif

#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define rep(i, b, e) for (intmax_t i = (b), i##_limit = (e); i < i##_limit; ++i)
#define repc(i, b, e)                                                          \\
  for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)
#define repr(i, b, e)                                                          \\
  for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)
#define var(Type, ...)                                                         \\
  Type __VA_ARGS__;                                                            \\
  input(__VA_ARGS__)

constexpr size_t operator""_zu(unsigned long long value) { return value; };
constexpr intmax_t operator""_jd(unsigned long long value) { return value; };
constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };

constexpr int INF = 0x3f3f3f3f;
constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;

template <class T, class Compare = less<>>
using MaxHeap = priority_queue<T, vector<T>, Compare>;
template <class T, class Compare = greater<>>
using MinHeap = priority_queue<T, vector<T>, Compare>;

inline void input() {}
template <class Head, class... Tail>
inline void input(Head &&head, Tail &&...tail) {
  cin >> head;
  input(forward<Tail>(tail)...);
}

template <class Container, class Value = typename Container::value_type,
          enable_if_t<!is_same<Container, string>::value, nullptr_t> = nullptr>
inline istream &operator>>(istream &is, Container &vs) {
  for (auto &v : vs)
    is >> v;
  return is;
}

inline void output() { cout << "\\n"; }
template <class Head, class... Tail>
inline void output(Head &&head, Tail &&...tail) {
  cout << head;
  if (sizeof...(tail))
    cout << " ";
  output(forward<Tail>(tail)...);
}

template <class Container, class Value = typename Container::value_type,
          enable_if_t<!is_same<Container, string>::value, nullptr_t> = nullptr>
inline ostream &operator<<(ostream &os, const Container &vs) {
  static constexpr const char *delim[] = {" ", ""};
  for (auto it = begin(vs); it != end(vs); ++it) {
    os << delim[it == begin(vs)] << *it;
  }
  return os;
}

template <class Iterator>
inline void join(const Iterator &Begin, const Iterator &End,
                 const string &delim = "\\n", const string &last = "\\n") {
  for (auto it = Begin; it != End; ++it) {
    cout << ((it == Begin) ? "" : delim) << *it;
  }
  cout << last;
}

template <class T> inline vector<T> makeVector(const T &initValue, size_t sz) {
  return vector<T>(sz, initValue);
}

template <class T, class... Args>
inline auto makeVector(const T &initValue, size_t sz, Args... args) {
  return vector<decltype(makeVector<T>(initValue, args...))>(
      sz, makeVector<T>(initValue, args...));
}

template <class Func> class FixPoint : Func {
public:
  explicit constexpr FixPoint(Func &&f) noexcept : Func(forward<Func>(f)) {}

  template <class... Args>
  constexpr decltype(auto) operator()(Args &&...args) const {
    return Func::operator()(*this, std::forward<Args>(args)...);
  }
};

template <class Func>
static inline constexpr decltype(auto) makeFixPoint(Func &&f) noexcept {
  return FixPoint<Func>{forward<Func>(f)};
}

template <class Container> struct reverse_t {
  Container &c;
  reverse_t(Container &c) : c(c) {}
  auto begin() { return c.rbegin(); }
  auto end() { return c.rend(); }
};

template <class Container> auto reversed(Container &c) {
  return reverse_t<Container>(c);
}

template <class T> inline bool chmax(T &a, const T &b) noexcept {
  return b > a && (a = b, true);
}

template <class T> inline bool chmin(T &a, const T &b) noexcept {
  return b < a && (a = b, true);
}

template <class T> inline T diff(const T &a, const T &b) noexcept {
  return a < b ? b - a : a - b;
}

void ioinit() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout << fixed << setprecision(10);
  clog << fixed << setprecision(10);
}
// }}} End Header

vector<intmax_t> divisor(intmax_t n) {
  vector<intmax_t> ret;

  for (intmax_t i = 1; i * i <= n; ++i) {
    if (n % i == 0) {
      ret.emplace_back(i);
      if (i * i != n) {
        ret.emplace_back(n / i);
      }
    }
  }

  sort(ret.begin(), ret.end());
  return ret;
}

signed main() {
  ioinit();

  var(intmax_t, N);

  intmax_t res = 0;
  repc(c, 1, N) { res += divisor(N - c).size(); }
  output(res);

  return 0;
}

#pragma GCC optimize("Ofast")
#include "bits/stdc++.h"

// Begin Header {{{
using namespace std;

#ifndef DEBUG
#define dump(...)
#endif

#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define rep(i, b, e) for (intmax_t i = (b), i##_limit = (e); i < i##_limit; ++i)
#define repc(i, b, e)                                                          \\
  for (intmax_t i = (b), i##_limit = (e); i <= i##_limit; ++i)
#define repr(i, b, e)                                                          \\
  for (intmax_t i = (b), i##_limit = (e); i >= i##_limit; --i)
#define var(Type, ...)                                                         \\
  Type __VA_ARGS__;                                                            \\
  input(__VA_ARGS__)

constexpr size_t operator""_zu(unsigned long long value) { return value; };
constexpr intmax_t operator""_jd(unsigned long long value) { return value; };
constexpr uintmax_t operator""_ju(unsigned long long value) { return value; };

constexpr int INF = 0x3f3f3f3f;
constexpr intmax_t LINF = 0x3f3f3f3f3f3f3f3f_jd;

template <class T, class Compare = less<>>
using MaxHeap = priority_queue<T, vector<T>, Compare>;
template <class T, class Compare = greater<>>
using MinHeap = priority_queue<T, vector<T>, Compare>;

inline void input() {}
template <class Head, class... Tail>
inline void input(Head &&head, Tail &&...tail) {
  cin >> head;
  input(forward<Tail>(tail)...);
}

template <class Container, class Value = typename Container::value_type,
          enable_if_t<!is_same<Container, string>::value, nullptr_t> = nullptr>
inline istream &operator>>(istream &is, Container &vs) {
  for (auto &v : vs)
    is >> v;
  return is;
}

inline void output() { cout << "\\n"; }
template <class Head, class... Tail>
inline void output(Head &&head, Tail &&...tail) {
  cout << head;
  if (sizeof...(tail))
    cout << " ";
  output(forward<Tail>(tail)...);
}

template <class Container, class Value = typename Container::value_type,
          enable_if_t<!is_same<Container, string>::value, nullptr_t> = nullptr>
inline ostream &operator<<(ostream &os, const Container &vs) {
  static constexpr const char *delim[] = {" ", ""};
  for (auto it = begin(vs); it != end(vs); ++it) {
    os << delim[it == begin(vs)] << *it;
  }
  return os;
}

template <class Iterator>
inline void join(const Iterator &Begin, const Iterator &End,
                 const string &delim = "\\n", const string &last = "\\n") {
  for (auto it = Begin; it != End; ++it) {
    cout << ((it == Begin) ? "" : delim) << *it;
  }
  cout << last;
}

template <class T> inline vector<T> makeVector(const T &initValue, size_t sz) {
  return vector<T>(sz, initValue);
}

template <class T, class... Args>
inline auto makeVector(const T &initValue, size_t sz, Args... args) {
  return vector<decltype(makeVector<T>(initValue, args...))>(
      sz, makeVector<T>(initValue, args...));
}

template <class Func> class FixPoint : Func {
public:
  explicit constexpr FixPoint(Func &&f) noexcept : Func(forward<Func>(f)) {}

  template <class... Args>
  constexpr decltype(auto) operator()(Args &&...args) const {
    return Func::operator()(*this, std::forward<Args>(args)...);
  }
};

template <class Func>
static inline constexpr decltype(auto) makeFixPoint(Func &&f) noexcept {
  return FixPoint<Func>{forward<Func>(f)};
}

template <class Container> struct reverse_t {
  Container &c;
  reverse_t(Container &c) : c(c) {}
  auto begin() { return c.rbegin(); }
  auto end() { return c.rend(); }
};

template <class Container> auto reversed(Container &c) {
  return reverse_t<Container>(c);
}

template <class T> inline bool chmax(T &a, const T &b) noexcept {
  return b > a && (a = b, true);
}

template <class T> inline bool chmin(T &a, const T &b) noexcept {
  return b < a && (a = b, true);
}

template <class T> inline T diff(const T &a, const T &b) noexcept {
  return a < b ? b - a : a - b;
}

void ioinit() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout << fixed << setprecision(10);
  clog << fixed << setprecision(10);
}
// }}} End Header

// SmartSieve {{{
class SmartSieve {
  intmax_t L, R, M;
  vector<intmax_t> small;         // 小さい篩 [2, sqrt(R))
  vector<vector<intmax_t>> large; // 大きい篩 [L, R)
  vector<intmax_t> aux;           // aux[i] := large[i] の素因数の積

public:
  SmartSieve(intmax_t L, intmax_t R) : L(L), R(R), M(sqrt(R) + 1) {
    small.resize(M);
    iota(small.begin(), small.end(), 0);
    large.resize(R - L);
    aux.assign(R - L, 1);

    for (intmax_t i = 2; i * i < R; ++i) {
      if (small[i] < i)
        continue;

      for (intmax_t j = i * i; j < M; j += i) {
        if (small[j] == j)
          small[j] = i;
      }

      for (intmax_t j = (L + i - 1) / i * i; j < R; j += i) {
        intmax_t k = j;
        do {
          if (aux[j - L] * aux[j - L] > R)
            break;

          large[j - L].emplace_back(i);
          aux[j - L] *= i;
          k /= i;
        } while (k % i == 0);
      }
    }
  }

  bool isPrime(intmax_t n) const {
    assert(L <= n && n < R);
    if (n < M)
      return (2 <= n && small[n] == n);
    return (aux[n - L] == 1);
  }

  vector<intmax_t> primeFactorize(intmax_t n) {
    assert(L <= n && n < R);
    vector<intmax_t> ret = large[n - L];
    n /= aux[n - L];
    if (n >= M) {
      ret.emplace_back(n);
      return ret;
    }
    while (n > 1) {
      ret.emplace_back(small[n]);
      n /= small[n];
    }
    return ret;
  }
};
// }}}

signed main() {
  ioinit();

  var(intmax_t, N);

  SmartSieve sieve(1, intmax_t(1e6) + 1);

  intmax_t res = 0;
  rep(c, 1, N) {
    const auto ps = sieve.primeFactorize(N - c);
    intmax_t m = 1;
    unordered_map<intmax_t, intmax_t> cs;
    for (const auto p : ps)
      cs[p]++;
    for (const auto c : cs)
      m *= (c.second + 1);
    res += m;
  }
  output(res);

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
int n, ans;
int pls(int x) {
  int res = 0;
  for (int i = 1; i < sqrt(x); i++)
    if (!(x % i))
      res += 2;
  if (int(sqrt(x)) * int(sqrt(x)) == x)
    res++;
  return res;
}
int main() {
  cin >> n;
  for (int i = 1; i < n; i++)
    ans += pls(i);
  cout << ans << endl;
  return 0;
}


#include "bits/stdc++.h"
using namespace std;
#define MODULO 1000000007
#define PI 3.14159265359
typedef long long int ll;

ll coc(ll n) {
  ll res = 0;
  for (ll i = 1; i <= (sqrt(n)); ++i) {
    if (n % i == 0) {
      if ((i * i) == n)
        res++;
      else
        res += 2;
    }
  }
  return res;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  ll n;
  cin >> n;
  ll res = 0;
  for (int c = 1; c < n; ++c) {
    ll z = coc(n - c);
    res = res + z;
  }
  cout << res << endl;
  return 0;
}

#include "bits/stdc++.h"
using namespace std;
#define MODULO 1000000007
#define PI 3.14159265359
typedef long long int ll;
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  ll n;
  cin >> n;
  ll res = 0;
  for (int c = 1; c < n; ++c) {
    res = res + (n - 1) / c;
  }
  cout << res << endl;
  return 0;
}


#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define vi vector<int>
using namespace std;
const int INF = 1001001001;
const int MOD = 1e9 + 7;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template <class T> inline bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}

inline vector<ll> divisor(ll n) {
  vector<ll> res;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      res.push_back(i);
      if (i != n / i)
        res.push_back(n / i);
    }
  }
  sort(all(res));
  return res;
}

int main() {
  cin.tie(0), ios::sync_with_stdio(false);
  int n;
  cin >> n;
  ll ans = 0;
  for (int i = 1; i < n; i++) {
    auto res = divisor(n - i);
    ans += res.size();
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define vi vector<int>
using namespace std;
const int INF = 1001001001;
const int MOD = 1e9 + 7;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template <class T> inline bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}

int main() {
  cin.tie(0), ios::sync_with_stdio(false);
  int n;
  cin >> n;
  vi cnt(n);
  for (int i = 1; i <= n; i++) {
    for (int j = 0; j < n; j += i) {
      cnt[j]++;
    }
  }
  ll ans = 0;
  for (int i = 1; i < n; i++)
    ans += cnt[i];
  cout << ans;
  return 0;
}


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

set<int> divisor(int n) {
  set<int> ret;
  for (auto i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.insert(i);
      if (n % (n / i) == 0)
        ret.insert(n / i);
    }
  }
  return ret;
}

int main() {
  int64_t n, ans = 0;
  cin >> n;
  for (auto i = 1; i <= n; i++) {
    int64_t tmp = n - i;
    if (tmp == 1)
      ans++;
    else {
      auto p = divisor(tmp);
      ans += p.size();
    }
  }
  cout << ans << endl;
  return 0;
}

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

int main() {
  int64_t n, ans = 0;
  cin >> n;
  for (auto a = 1; a < n; a++) {
    ans += n / a;
    if (n % a == 0)
      ans--;
  }
  cout << ans << endl;
  return 0;
}


// A x B + C

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
#define rep(i, x, y) for (ll i = x; i < y; i++)
#define nvarep(n, a)                                                           \\
  ll n;                                                                        \\
  cin >> n;                                                                    \\
  vector<ll> a(n);                                                             \\
  rep(i, 0, n) cin >> a[i]
#define vecrep(n, a, type)                                                     \\
  vector<type> a(n);                                                           \\
  rep(i, 0, n) cin >> a[i]
#define lcm(a, b) (a / __gcd(a, b) * b)
#define range(a) (a).begin(), (a).end()
#define nnn "\\n"
#define spa " "
using P = pair<ll, ll>;
using graph = vector<vector<ll>>;
const int inf = 2147483647;         // 2*10^9
const ll INF = 9223372036854775807; // 9*10^18

int d(int t) {
  int res = 0;
  for (int i = 1; i * i <= t; i++) {
    if (t % i == 0) {
      res++;
      if (t / i != i)
        res++;
    }
  }
  return res;
}

signed main() {
  int n;
  cin >> n;
  int ans = 0;
  rep(i, 1, n) { ans += d(i); }
  cout << ans << nnn;
  return 0;
}

// A x B + C

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
#define rep(i, x, y) for (ll i = x; i < y; i++)
#define nvarep(n, a)                                                           \\
  ll n;                                                                        \\
  cin >> n;                                                                    \\
  vector<ll> a(n);                                                             \\
  rep(i, 0, n) cin >> a[i]
#define vecrep(n, a, type)                                                     \\
  vector<type> a(n);                                                           \\
  rep(i, 0, n) cin >> a[i]
#define lcm(a, b) (a / __gcd(a, b) * b)
#define range(a) (a).begin(), (a).end()
#define nnn "\\n"
#define spa " "
using P = pair<ll, ll>;
using graph = vector<vector<ll>>;
const int inf = 2147483647;         // 2*10^9
const ll INF = 9223372036854775807; // 9*10^18

int d(int t) {
  map<int, int> m;
  for (int i = 2; i * i <= t; i++) {
    while (t % i == 0) {
      m[i]++;
      t /= i;
    }
  }
  if (t != 1)
    m[t]++;
  int res = 1;
  for (auto i : m)
    res *= (i.second + 1);
  return res;
}

signed main() {
  int n;
  cin >> n;
  int ans = 0;
  rep(i, 1, n) { ans += d(i); }
  cout << ans << nnn;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main() {

  int a, b, c, d, e;
  cin >> a;
  long long m = 0;
  for (int i = 2; i < a; i++) {
    for (int j = 1; j <= sqrt(i); j++) {
      if (i % j == 0) {
        if (j == i / j)
          m++;
        else
          m += 2;
      }
    }
  }
  m++;
  cout << m << endl;
}

#include <bits/stdc++.h>
using namespace std;
int arr[1000004];
void sieve() {

  for (int i = 1; i <= 1000000; i++)
    arr[i] = i;
  for (int i = 2; i <= 1000000; i += 2)
    arr[i] = 2;
  arr[1] = 1;
  for (int i = 3; i * i <= 1000000; i += 2) {
    if (arr[i] == i) {
      arr[i] = i;
      for (int j = i * i; j <= 1000000; j += i) {
        arr[j] = i;
      }
    }
  }
}

int get_divisor(int x) {
  map<int, int> mp;
  int mul = 1;
  while (x != 1) {
    int l = arr[x];
    while (x % l == 0) {

      x /= l;
      mp[l]++;
      if (x == 1)
        break;
    }
  }
  for (auto it = mp.begin(); it != mp.end(); it++) {

    if (it->first != 1)
      mul = mul * (it->second + 1);
  }
  return mul;
}

int main() {
  int a, b, c, d, e;
  cin >> a;
  sieve();
  long long sum = 0;
  for (int i = 2; i < a; i++) {

    sum += (get_divisor(i));
  }
  sum++;
  cout << sum << endl;
}


// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr auto INF = 9223372036854775807;
typedef long long int ll;
typedef unsigned long long int ull;
typedef unsigned long int ul;
#define f(i, a, b) for (ll i = (ll)a; i < (ll)b; i += 1)
#define rf(i, a, b) for (ll i = (ll)a; i >= (ll)b; i -= 1)
#define endl '\\n'
#define N 1000000007 // prime modulo value
#define M 998244353
#define all(x) x.begin(), x.end()
#define mkp(a, b) make_pair(a, b)
using namespace std;
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    // http://xorshift.di.unimi.it/splitmix64.c
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }

  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};
inline int mex(unordered_set<int> st) {
  int m = 0;
  while (st.find(m) != st.end()) {
    m += 1;
  }
  return m;
}
inline int calculateGrundy(int n) {
  if (n == 1)
    return 0;
  unordered_set<int> mexi;
  for (int i = 1; i <= sqrt(n); i += 1) {
    if (n % i == 0) {
      if (n / i != n)
        mexi.insert(calculateGrundy(n / i));
      mexi.insert(calculateGrundy(i));
    }
  }
  return mex(mexi);
}
inline ll gcd(ll a, ll b) {
  // This is code taken from geeksforgeek
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
/*ll power(ll x, ll y)
{
        // This is code taken from geeksforgeek
        ll res = 1;

        x = x % N;
        if (x == 0) return 0;
        while (y > 0)
        {
                if (y & 1)
                        res = (res * x) % N;
                y = y >> 1;
                x = (x * x) % N;
        }
        return res;
}*/
ll power(ll x, ll y) {
  ll res = 1;

  x = x;

  while (y > 0) {

    if (y & 1)
      res = (res * x);

    y = y >> 1;
    x = (x * x);
  }
  return res;
}

/*ll modInverse(ll n, ll p)
{
        return power(n, p - 2, p);
}*/

ll sum(ll n) { return (n * (n + 1)) / 2; }
ll sum_digit(ll n) {
  ll ans = 0;
  while (n) {
    ans += n % 10;
    n /= 10;
  }
  return ans;
}

ll num_of_divisors(ll n) {
  unordered_set<ll> st;
  for (ll i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      st.insert(i);
      st.insert(n / i);
    }
  }
  return st.size();
}

int main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  ll n;
  cin >> n;
  ll ans = 0;
  f(i, 1, n) {
    f(j, 1, n) {
      if (i * j < n)
        ans += 1;
    }
  }
  cout << ans;
  return 0;
}

// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#include <algorithm>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
constexpr auto INF = 9223372036854775807;
typedef long long int ll;
typedef unsigned long long int ull;
typedef unsigned long int ul;
#define f(i, a, b) for (ll i = (ll)a; i < (ll)b; i += 1)
#define rf(i, a, b) for (ll i = (ll)a; i >= (ll)b; i -= 1)
#define endl '\\n'
#define N 1000000007 // prime modulo value
#define M 998244353
#define all(x) x.begin(), x.end()
#define mkp(a, b) make_pair(a, b)
using namespace std;
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    // http://xorshift.di.unimi.it/splitmix64.c
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }

  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};
inline int mex(unordered_set<int> st) {
  int m = 0;
  while (st.find(m) != st.end()) {
    m += 1;
  }
  return m;
}
inline int calculateGrundy(int n) {
  if (n == 1)
    return 0;
  unordered_set<int> mexi;
  for (int i = 1; i <= sqrt(n); i += 1) {
    if (n % i == 0) {
      if (n / i != n)
        mexi.insert(calculateGrundy(n / i));
      mexi.insert(calculateGrundy(i));
    }
  }
  return mex(mexi);
}
inline ll gcd(ll a, ll b) {
  // This is code taken from geeksforgeek
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
/*ll power(ll x, ll y)
{
        // This is code taken from geeksforgeek
        ll res = 1;

        x = x % N;
        if (x == 0) return 0;
        while (y > 0)
        {
                if (y & 1)
                        res = (res * x) % N;
                y = y >> 1;
                x = (x * x) % N;
        }
        return res;
}*/
ll power(ll x, ll y) {
  ll res = 1;

  x = x;

  while (y > 0) {

    if (y & 1)
      res = (res * x);

    y = y >> 1;
    x = (x * x);
  }
  return res;
}

/*ll modInverse(ll n, ll p)
{
        return power(n, p - 2, p);
}*/

ll sum(ll n) { return (n * (n + 1)) / 2; }
ll sum_digit(ll n) {
  ll ans = 0;
  while (n) {
    ans += n % 10;
    n /= 10;
  }
  return ans;
}

ll num_of_divisors(ll n) {
  unordered_set<ll> st;
  for (ll i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      st.insert(i);
      st.insert(n / i);
    }
  }
  return st.size();
}

int main() {
  ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  ll n;
  cin >> n;
  ll ans = 0;
  f(i, 1, n) {
    for (ll j = 1; i * j < n; j++) {
      ans++;
    }
  }
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
  long long n, j, i, p = 0, k, l;
  cin >> n;
  for (i = 1; i <= n - 1; i++) {
    k = n - i;
    for (j = 1; j <= sqrt(k); j++) {
      if (k % j == 0) {
        if (j * j == k)
          p = p + 1;
        else
          p = p + 2;
      }
    }
  }
  cout << p;

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  long long n, j, i, p = 0, k, l;
  cin >> n;
  p = p;
  for (i = 1; i <= n; i++) {
    p = p + n / i;
    if (n % i == 0) {
      p = p - 1;
    }
  }
  cout << p;

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define endl "\\n"
#define pb push_back
typedef long long ll;
int n, m;
pair<int, int> dice;
int main() {
  cin >> n;
  int ans = 0;
  for (int i = 1; i <= n; ++i) {
    int nf = 0;
    if (n - i <= 0)
      break;
    else if (n - i == 1) {
      ans++;
      continue;
    }
    int num = n - i;
    for (int j = 1; j <= sqrt(num); ++j) {
      if (num % j == 0) {
        if (num / j == j)
          nf += 1;
        else
          nf += 2;
      }
    }
    ans += nf;
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
using namespace std;
#define endl "\\n"
#define pb push_back
typedef long long ll;
int n, m;
ll ans = 0;
int factor[1000001];
// factor[i] stores the lowest prime that divides all numbers up to and
// including i
void init(int n) {
  factor[1] = 1;
  for (int i = 2; i <= n; ++i) {
    factor[i] = i;
  }
  for (int i = 4; i <= n; i += 2) {
    factor[i] = 2;
  }
  for (int i = 3; i * i <= n; ++i) {
    if (factor[i] == i) {
      for (int j = i * i; j <= n; j += i) {
        // if it has no prime factor before, then
        // stores the smallest prime divisor
        if (factor[j] == j)
          factor[j] = i;
      }
    }
  }
}
int fact(int n) {
  if (n == 1)
    return 1;
  int ans = 1, dup = factor[n], c = 1, j = n / factor[n];
  while (j != 1) {
    if (factor[j] == dup)
      c += 1;
    else {
      dup = factor[j];
      ans = ans * (c + 1);
      c = 1;
    }
    j = j / factor[j];
  }
  ans = ans * (c + 1);
  return ans;
}

int main() {
  cin >> n;
  init(n);
  for (int i = 1; i < n; ++i) {
    ans += fact(i);
  }
  cout << ans << endl;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
  long long int n;
  cin >> n;
  long long int cnt = 0;
  for (long long int i = 1; i <= n; i++) {
    for (long long int j = 1; j <= n; j++) {
      for (long long int k = 1; k <= n; k++) {
        if ((i * j) + k == n) {
          cnt++;
        }
      }
    }
  }
  cout << cnt << endl;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  long long int n;
  cin >> n;
  long long int cnt = 0;
  for (long long int i = 1; i < n; i++) {
    for (long long int j = 1; i * j < n; j++) {
      cnt++;
    }
  }
  cout << cnt << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl ("\\n")
#define pi (3.141592653589)
#define mod 1000000007
#define INF 1000000009
#define float double
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define so sizeof
#define pii pair<ll, ll>
#define all(c) c.begin(), c.end()
#define min3(a, b, c) min(c, min(a, b))
#define min4(a, b, c, d) min(d, min(c, min(a, b)))
#define max3(a, b, c) max(c, max(a, b))
#define max4(a, b, c, d) max(d, max(c, max(a, b)))
#define repe(i, a) for (auto i : a)
#define st string
#define rep(i, a, b) for (ll i = a; i <= b; i++)
#define rrep(i, a, b) for (ll i = b; i >= a; i--)
#define fast                                                                   \\
  ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
void solve() {
  ll n;
  cin >> n;
  ll cnt = 0;
  rep(i, 1, n - 1) {
    for (ll j = 1; j * j <= n - i; j++) {
      if ((j * ((n - i) / j)) == (n - i)) {
        //  cout<<j<<" "<<(n-i)/j<<" "<<i<<endl;
        if (j != (n - i) / j)
          cnt += 2;
        else
          cnt++;
      }
    }
  }
  cout << cnt << endl;
}
int main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  fast
  // ll t;
  // cin>>t;
  // while(t--)
  solve();
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl ("\\n")
#define pi (3.141592653589)
#define mod 1000000007
#define INF 1000000009
#define float double
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define so sizeof
#define pii pair<ll, ll>
#define all(c) c.begin(), c.end()
#define min3(a, b, c) min(c, min(a, b))
#define min4(a, b, c, d) min(d, min(c, min(a, b)))
#define max3(a, b, c) max(c, max(a, b))
#define max4(a, b, c, d) max(d, max(c, max(a, b)))
#define repe(i, a) for (auto i : a)
#define st string
#define rep(i, a, b) for (ll i = a; i <= b; i++)
#define rrep(i, a, b) for (ll i = b; i >= a; i--)
#define fast                                                                   \\
  ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
void solve() {
  ll n;
  cin >> n;
  ll cnt = 0;
  rep(i, 1, n - 1) { cnt += (n - 1) / i; }
  //}
  cout << cnt << endl;
}
int main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  fast
  // ll t;
  // cin>>t;
  // while(t--)
  solve();
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
/*******  All Required define Pre-Processors and Constants    *******/

#define int long long
#define ull unsigned long long
#define ld long double
#define mem(a, b) memset(a, (b), sizeof(a))
#define rep(i, j, k) for (int i = j; i < k; ++i)
#define rrep(i, j, k) for (int i = j; i > k; --i)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define foreach(i, a) for (auto i : a)
#define forEach(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(A, B, C) assert(B <= A && A <= C)
#define debug(a) cout << #a << ": " << a << endl
#define flag(n) cout << "here " << n << endl
#define w(x)                                                                   \\
  int x;                                                                       \\
  cin >> x;                                                                    \\
  while (x--)
#define mp make_pair
#define pb push_back

#define endl '\\n';
#define io                                                                     \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);

#define TRACE
#ifdef TRACE
#define see(...) __f(#__VA_ARGS__, __VA_ARGS__);
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
  cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
  const char *comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
#else
#endif

const int POSITIVE_INFINITY = 9223372036854775807;
const int NEGATIVE_INFINITY = -9223372036854775807;
const ld PI = acos(-1.0);
const int MOD = 1000000007;
const int INF = 1e18;
const int N = 1e6 + 5;

int32_t main() {
  io;
  // freopen("input.txt","r",stdin);
  // freopen("output.txt","w",stdout);

  int n, ans = 0;
  cin >> n;
  rep(i, 1, n) rep(j, 1, n) if (i * j < n) ans++;
  cout << ans << endl;

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
/*******  All Required define Pre-Processors and Constants    *******/

#define int long long
#define ull unsigned long long
#define ld long double
#define mem(a, b) memset(a, (b), sizeof(a))
#define rep(i, j, k) for (int i = j; i < k; ++i)
#define rrep(i, j, k) for (int i = j; i > k; --i)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define foreach(i, a) for (auto i : a)
#define forEach(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define in(A, B, C) assert(B <= A && A <= C)
#define debug(a) cout << #a << ": " << a << endl
#define flag(n) cout << "here " << n << endl
#define w(x)                                                                   \\
  int x;                                                                       \\
  cin >> x;                                                                    \\
  while (x--)
#define mp make_pair
#define pb push_back

#define endl '\\n';
#define io                                                                     \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);

#define TRACE
#ifdef TRACE
#define see(...) __f(#__VA_ARGS__, __VA_ARGS__);
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
  cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
  const char *comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
#else
#endif

const int POSITIVE_INFINITY = 9223372036854775807;
const int NEGATIVE_INFINITY = -9223372036854775807;
const ld PI = acos(-1.0);
const int MOD = 1000000007;
const int INF = 1e18;
const int N = 1e6 + 5;

int32_t main() {
  io;
  // freopen("input.txt","r",stdin);
  // freopen("output.txt","w",stdout);

  int n, ans = 0;
  cin >> n;
  for (int i = 1; i < n; i++) {
    for (int j = 1; i * j < n; j++)
      ans++;
  }

  cout << ans << endl;
  return 0;
}


// AC - C - A x B + C

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

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);

  int n, r, i, j, d, s = 0;
  cin >> n;
  r = sqrt(n);

  for (i = 1; i <= n; i++)
    for (j = 1; j <= n; j++) {
      d = n - (i * j);
      if (d > 0)
        s = s + 1;
    }
  cout << s << "\\n";
  return 0;
}

// AC - C - A x B + C

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

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);

  int n, r, i, j, d, s = 0;
  cin >> n;
  r = sqrt(n);

  for (i = 1; i <= n; i++)
    for (j = 1; j <= (n / i); j++) {
      d = n - (i * j);
      if (d > 0)
        s = s + 1;
    }
  cout << s << "\\n";
  return 0;
}


///*.......................Shadman Sakib Utshob............................*///

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

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;

#define Boost                                                                  \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0), cout.tie(0)
#define see(x) cerr << __LINE__ << ": " << (#x) << " is " << (x) << '\\n';
#define pb push_back
#define seecontent(v)                                                          \\
  cout << (#v) << " is ";                                                      \\
  for (auto x : v) {                                                           \\
    cout << x << " ";                                                          \\
  }                                                                            \\
  cout << "\\n\\n";
#define inf 1e10
#define mp make_pair
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define ll long long
#define pii pair<ll, ll>
#define MOD 1000000007
#define fileout freopen("output.txt", "w", stdout)
#define mem(x, i) memset(x, i, sizeof x)
#define Ones(x) __builtin_popcount(x);
#define PI acos(-1.0)
#define ff first
#define ss second
#define T                                                                      \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define ok cout << "ok" << endl;
#define all(x) (x).begin(), (x).end()
#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>
#define nln cout << endl;
#define maxn 300005

int dx[] = {-1, 0, 1, 0}; // up,right,down,left
int dy[] = {0, 1, 0, -1};

int main() {
  Boost;
  ll n, i, x = 0, val, j, div = 0, ans = 0, k, mul;
  cin >> n;
  vector<ll> a(n);
  for (i = 1; i <= n - 1; i++) {
    val = n - i;
    // see(val)
    div = 0;
    if (val == 1) {
      ans++;
    } else {
      for (j = 1; j <= val; j++) {
        for (k = 1; k <= val; k++) {
          mul = j * k;
          if (mul > val)
            break;
          if (mul == val) {
            div++;
            break;
          }
        }
      }
      // div*=2;

      //            x=sqrt(val);
      //            if((x*x)==val)
      //            {
      //                div--;
      //            }
      // see(div)
      ans += div;
    }
  }
  cout << ans << endl;

  return 0;
}

// THIS IS THE AATMANIRBHAR SOLUTION I FOUND..!!!!!
#define see(x) cerr << __LINE__ << ": " << (#x) << " is " << (x) << '\\n';
#define pb push_back
#include <bits/stdc++.h>
using namespace std;
#define int long long
// #define int double
// #define ll long long
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define P push
#define vvi vector<vector<int>>
#define vi vector<int>
#define vf vector<float>
#define vc vector<char>
#define vs vector<string>
#define pii vector<pair<int, int>>
#define sz(a) (int)a.size()
#define all(a) a.begin(), a.end()
#define sort(v) sort(all(v))
#define rep(i, a, b) for (int i = a; i < b; i++)
#define per(j, a, b) for (int j = a - 1; j >= b; j--)
#define binod                                                                  \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
const int N = 1e9 + 7, N1 = 1e7 + 5, N2 = 1e6 + 3, N3 = 1e5 + 3;
#define IX INT_MAX
#define IM INT_MIN

void solve() {
  int n;
  cin >> n;
  int cnt = 0;
  vi ans(n + 5, 0);
  for (int i = 1; i < sqrt(n); i++) {
    // see(i)
    for (int j = i; j < n; j++) {
      if (i == j and i * i < n)
        cnt++;
      else if (i * j < n)
        cnt += 2;
      else
        break;
    }
    // see(cnt)
  }
  cout << cnt;
}

signed main() {
  binod;
  int t1 = 1;
  // cin>>t1;
  //  cout<<fixed<<setprecision(9);
  while (t1--) {
    solve();
    cout << endl;
  }
}

// Don't judge me or anyone
// this is life,
// not a reality show


#include <bits/stdc++.h>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long LL;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
  if (a > b)
    a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
  if (a < b)
    a = b;
}

int main() {
  int N;
  cin >> N;

  LL ans = 0;
  for (int C = 1; C < N; C++) {
    int val = N - C;

    int valsqrt = (int)round(sqrt(val));

    int a = 1;
    while (a <= valsqrt) {
      if (val % a != 0) {
        a++;
        continue;
      }

      int b = val / a;
      if (a == b) {
        ans++;
      } else {
        ans += 2;
      }
      a++;
    }
  }

  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long LL;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
  if (a > b)
    a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
  if (a < b)
    a = b;
}

int main() {
  int N;
  cin >> N;

  int ans = 0;
  for (int a = 1; a <= N - 1; a++) {
    int count = (N - 1) / a;
    ans += count;
  }

  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>

using namespace std;
// using namespace __gnu_pbds;

#define int long long
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#define ff first
#define ss second
#define vi vector<ll>
#define vii vector<vector<ll>>
#define vpi vector<pii>
#define mod 1000000007
#define MOD 1000000007
#define full(a) a.begin(), a.end()
#define inf INT_MAX
#define minf INT_MIN
#define dd double
#define fori(x, n) for (ll i = x; i < n; i++)
#define umap unordered_map<ll, ll>
#define mmap map<ll, ll>
#define mm 998244353

// typedef tree<pii,null_type,less<pii>,rb_tree_tag,
// tree_order_statistics_node_update>PBDS;

int32_t main() {

  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif

  ll t;
  t = 1;
  // cin>>t;
  while (t--) {
    ll n;
    cin >> n;

    ll cnt = 0;

    for (int i = 1; i < n; i++) {
      ll num = n - i;

      for (int j = 1; j * j <= num; j++)
        if (num % j == 0) {
          if ((j) == (num / j))
            cnt++;
          else
            cnt += 2;
        }
    }

    cout << cnt;
  }

  return 0;
}

#include <bits/stdc++.h>

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>

using namespace std;
// using namespace __gnu_pbds;

#define int long long
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#define ff first
#define ss second
#define vi vector<ll>
#define vii vector<vector<ll>>
#define vpi vector<pii>
#define mod 1000000007
#define MOD 1000000007
#define full(a) a.begin(), a.end()
#define inf INT_MAX
#define minf INT_MIN
#define dd double
#define fori(x, n) for (ll i = x; i < n; i++)
#define umap unordered_map<ll, ll>
#define mmap map<ll, ll>
#define mm 998244353

// typedef tree<pii,null_type,less<pii>,rb_tree_tag,
// tree_order_statistics_node_update>PBDS;

vi prime;

void sieve() {
  vi p;
  p.resize(1001, 1);
  prime.pb(2);

  for (int i = 3; i <= 1e3; i++)
    if (p[i] == 1) {
      prime.pb(i);
      for (int j = i + i; j <= 1e3; j += i)
        p[j] = 0;
    }

  return;
}

ll res(ll num) {
  if (num == 1)
    return 1;

  // ll nn = sqrt(num);

  // ll ck=0;
  // if(nn*nn==num)ck=1;

  ll result = 1;

  for (auto x : prime)
    if (x * x > num)
      break;
    else if (num % x == 0) {
      ll cnt = 0;
      while (num % x == 0) {
        num = num / x;
        cnt++;
      }
      result *= (cnt + 1);
    }

  if (num != 1)
    result *= 2;

  return result;
}

int32_t main() {

  ios_base::sync_with_stdio(false);
  cin.tie(NULL);

#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif

  sieve();
  ll t;
  t = 1;
  // cin>>t;
  while (t--) {
    ll n;
    cin >> n;

    ll cnt = 0;

    for (int i = 1; i < n; i++) {
      ll num = n - i;
      cnt += res(num);
    }

    // cout<<res(45);
    cout << cnt;
  }

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, s = 0;
  cin >> n;
  for (int i = 1; i < n; i++) {
    for (int j = 1; j * j <= n - i; j++) {
      if ((n - i) % j == 0) {
        s++;
        if ((n - i) / j != j)
          s++;
      }
    }
  }
  cout << s;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, s = 0;
  scanf("%d", &n);
  for (int i = 1; i < n; i++) {
    for (int j = 1; j * j <= n - i; j++) {
      if ((n - i) % j == 0) {
        s++;
        if ((n - i) / j != j)
          s++;
      }
    }
  }
  printf("%d\\n", s);
}


#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>

typedef long long ll;
#define ALL(obj) (obj).begin(), (obj).end()
#define MOD 1000000007

using namespace std;

long long GCD(long long x, long long y) {
  long long r, tmp;
  if (x < y) {
    tmp = x;
    x = y;
    y = tmp;
  }
  while (y != 0) {
    r = x % y;
    x = y;
    y = r;
  }
  return x;
}
long long LCM(long long x, long long y) {
  long long lcm = (x * y) / GCD(x, y);
  return lcm;
}

int bubblesort(int n) {
  vector<int> data(n);
  int num = 0;
  for (int end = n - 1; end > 0; end--) {
    for (int j = 0; j < end; j++) {
      if (data[j + 1] < data[j]) {
        int temp = data[j];
        data[j] = data[j + 1];
        data[j + 1] = temp;
        num++;
      }
    }
  }
  return num;
}

int main() {
  ll n;
  cin >> n;
  ll fx = n;
  ll ans = 0;
  for (ll i = 1; i < fx; i++) {
    n--;
    ;
    for (ll j = 1; j < fx; j++) {
      if (n % j == 0) {
        ans++;
      }
    }
  }
  cout << ans << endl;
  return 0;
}

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>

typedef long long ll;
#define ALL(obj) (obj).begin(), (obj).end()
#define MOD 1000000007

using namespace std;

long long GCD(long long x, long long y) {
  long long r, tmp;
  if (x < y) {
    tmp = x;
    x = y;
    y = tmp;
  }
  while (y != 0) {
    r = x % y;
    x = y;
    y = r;
  }
  return x;
}
long long LCM(long long x, long long y) {
  long long lcm = (x * y) / GCD(x, y);
  return lcm;
}

int bubblesort(int n) {
  vector<int> data(n);
  int num = 0;
  for (int end = n - 1; end > 0; end--) {
    for (int j = 0; j < end; j++) {
      if (data[j + 1] < data[j]) {
        int temp = data[j];
        data[j] = data[j + 1];
        data[j + 1] = temp;
        num++;
      }
    }
  }
  return num;
}

int main() {
  ll n;
  cin >> n;
  ll ans = n - 1;
  for (ll i = 2; i < n; i++) {
    ans += n / i;
    if (n % i == 0) {
      ans--;
    }
  }
  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
  int n;
  cin >> n;

  int k = 1;
  for (int c = 1; c < n - 1; ++c) {
    int d = n - c;
    for (int i = 1; i <= sqrt(d); ++i) {
      if (d % i == 0) {
        k += 2;

        if (i == sqrt(d)) {
          --k;
        }
      }
    }
  }

  cout << k;

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
  int n;
  cin >> n;

  vector<int> c(n, 0);
  for (int i = 1; i < n; ++i) {
    for (int j = i; j < n; j += i) {
      ++c[j];
    }
  }

  int s = 0;
  for (int ci : c) {
    s += ci;
  }

  cout << s;

  return 0;
}


#include <algorithm>
#include <cstdio>
#include <iostream>
#include <locale.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
using namespace std;

int prime[1000000] = {}; // i番目の素数
bool is_prime[1000001];  // is_primeがtrueならiは素数
void sieve(int n)        // n以下の素数を列挙する
{
  int p = 0;
  for (int i = 0; i <= n; i++) {
    is_prime[i] = true;
  }
  is_prime[0] = is_prime[1] = false;
  for (int i = 2; i <= n; i++) {
    if (is_prime[i]) {
      prime[p++] = i;
      for (int j = 2 * i; j <= n; j += i) {
        is_prime[j] = false;
      }
    }
  }
}

int main() {
  int x, ans = 0;
  scanf("%d", &x);
  sieve(x);
  for (int i = 1; i < x; i++) {
    int rep = x - i, med = 1, tet = 0; // x-iの約数の個数がmed
    if (rep == 1) {
      ans++;
      break;
    }
    for (int j = 0;; j++) {
      if (rep % prime[j] == 0) {
        rep = rep / prime[j];
        tet++;
        j--;
        if (rep == 1) {
          med = med * (tet + 1);
          tet = 0;
          break;
        }
      } else if (tet != 0) {
        med = med * (tet + 1);
        tet = 0;
      }
    }
    ans += med;
    //	printf("%d %d\\n",x-i,med);
  }
  printf("%d", ans);
}

#include <algorithm>
#include <cstdio>
#include <iostream>
#include <locale.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
using namespace std;

int prime[1000000] = {}; // i番目の素数
int spf[10000001];       // 1~1000000までSPFを求めておく
bool is_prime[1000001];  // is_primeがtrueならiは素数
void sieve(int n)        // n以下の素数を列挙する
{
  int p = 0;
  for (int i = 0; i <= n; i++) {
    is_prime[i] = true;
    spf[i] = i;
  }
  is_prime[0] = is_prime[1] = false;
  for (int i = 2; i <= n; i++) {
    if (is_prime[i]) {
      prime[p++] = i;
      for (int j = 2 * i; j <= n; j += i) {
        is_prime[j] = false;
        spf[j] = i;
      }
    }
  }
}

int main() {
  int x, ans = 0;
  scanf("%d", &x);
  sieve(x);
  // printf("aa");
  for (int i = 1; i < x; i++) {
    int rep = x - i, med = 1, tet = 0, mae = 1; // x-iの約数の個数がmed
    if (rep == 1) {
      ans++;
      break;
    }
    if (is_prime[rep]) {
      med = 2;
    } else {
      for (;;) {
        mae = spf[rep]; // repを割り切る最小の素数を記録しておく
        rep /= mae;
        tet++;
        if (mae != spf[rep]) {
          med = med * (tet + 1);
          tet = 0;
        }
        if (rep == 1) {
          break;
        }
      }
    }
    ans += med;
    //	printf("%d %d\\n",x-i,med);
  }
  printf("%d", ans);
}


#include "string.h"
#include <bits/stdc++.h>
using namespace std;
#define int long long

int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout << setprecision(20) << fixed;

  int n;
  cin >> n;
  int c = 0;
  for (int i = 1; i < n; i++) {
    int t = n - i;
    for (int j = 1; j * j <= t; j++) {
      if (t % j == 0) {
        c += 2;
        if (j == t / j)
          c--;
      }
    }
  }
  cout << c << endl;
  return 0;
}

#include "string.h"
#include <bits/stdc++.h>
using namespace std;
#define int long long

int pf[1000006];
void fun() {
  pf[1] = 1, pf[0] = 1;
  for (int i = 0; i < 1000006; i++)
    pf[i] = i;
  for (int i = 2; i * i < 1000006; i++) {
    if (pf[i] == i) {
      for (int j = i; j < 1000006; j += i) {
        if (pf[j] == j)
          pf[j] = i;
      }
    }
  }
}
int fun1(int x) {
  int c = 1;
  while (x != 1) {
    int t = pf[x], c1 = 0;
    while (x % t == 0) {
      x /= pf[x];
      c1++;
    }
    c += c * c1;
  }
  return c;
}

int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout << setprecision(20) << fixed;

  int n;
  cin >> n;
  fun();
  int c = 0;
  for (int i = 1; i < n; i++) {
    int t = fun1(n - i);
    // cout<<t<<endl;
    c += t;
  }
  cout << c << endl;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, ans = 0;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
      if (i * j < n)
        ans++;
      //			for(int k=1;k<=n-i*j;k++)
      //			{
      //				if(i*j+k==n)ans++;
      ////				cout<<i<<' '<<j<<' '<<k ;
      //			}
    }
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, ans = 0;
  cin >> n;
  for (int i = 1; i < n; i++) {
    for (int j = 1; j <= int(n / i); j++) {
      if (i * j != n)
        ans++;
      //			for(int k=1;k<=n-i*j;k++)
      //			{
      //				if(i*j+k==n)ans++;
      ////				cout<<i<<' '<<j<<' '<<k ;
      //			}
    }
  }
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define int long long
int printDivisors(int n) {
  int king = 0;
  // Note that this loop runs till square root
  for (int i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      // If divisors are equal, print only one
      if (n / i == i)
        king++;
      // printf("%d ", i);

      else // Otherwise print both
        king += 2;
      // printf("%d %d ", i, n/i);
    }
  }
  return king;
}
int32_t main() {
  int n;
  cin >> n;
  int mega = 0;
  int fact;
  for (int i = 1; i < n; ++i) {
    fact = printDivisors(n - i);
    mega += fact;
  }
  cout << mega;
  return 0;
}

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

int32_t main() {
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; ++i) {
    ans += ((n + i - 1) / i) - 1;
  }
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define ll long long int
#define pb push_back
int main() {
  ll a, cnt = 0;
  cin >> a;
  for (ll i = 1; i < a; i++) {
    ll cur = a - i;
    for (ll j = 1; j <= sqrt(cur); j++) {
      if (j * j == cur)
        cnt++;
      else if (cur % j == 0)
        cnt += 2;
    }
  }
  cout << cnt << endl;
}

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define ll long long int
#define pb push_back
int main() {
  ll a, cnt = 0;
  cin >> a;
  for (ll i = 1; i <= a; i++) {
    cnt += a / i;
    if (a % i == 0)
      cnt--;
  }
  cout << cnt << endl;
}


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

int cal(long long M) {
  long long count_sum = 1;
  cin >> M;

  for (long long p = 2; p <= M; p++) {
    long long ex = 1;
    if (M % p != 0) {
      continue;
    }
    if (M % p == 0) {
      while (M % p == 0) {
        M = M / p;
        ex += 1;
      }
    }
    count_sum *= ex;
  }
  return count_sum;
}

int main() {
  long long N;
  cin >> N;
  long long j, M, sum = 0;
  for (long long i = 0; i < N - 1; i++) {
    j = i + 1;
    M = N - j;
    sum += cal(M);
  }
  cout << sum << endl;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  int N, sum = 0;
  cin >> N;
  for (int i = 1; i < N; i++) {
    int j = 1, count = 0;
    while (i * j < N) {
      count++;
      j++;
    }
    sum += count;
  }
  cout << sum << endl;
}