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

#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using P = pair<ll, ll>;
string char_to_string(char val) { return string(1, val); }
int char_to_int(char val) { return val - '0'; }
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
struct edge {
  ll to, cost;
};

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

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

int main() {
  int N;
  cin >> N;
  ll ans = 0;
  for (int i = 1; i < N; ++i) {
    int tmp = N - i;
    auto x = divisor(tmp);
    ans += x.size();
  }
  cout << ans << endl;
}

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

#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
using ll = long long;
using P = pair<ll, ll>;
string char_to_string(char val) { return string(1, val); }
int char_to_int(char val) { return val - '0'; }
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
struct edge {
  ll to, cost;
};

// Sieve of Eratosthenes
// (*this)[i] = (divisor of i, greater than 1)
// Example: [0, 1, 2, 3, 2, 5, 3, 7, 2, 3, 2, 11, ...]
// Complexity: Space O(MAXN), Time (construction) O(MAXNloglogMAXN)
struct SieveOfEratosthenes : std::vector<int> {
  std::vector<int> primes;
  SieveOfEratosthenes(int MAXN) : std::vector<int>(MAXN + 1) {
    std::iota(begin(), end(), 0);
    for (int i = 2; i <= MAXN; i++) {
      if ((*this)[i] == i) {
        primes.push_back(i);
        for (int j = i; j <= MAXN; j += i)
          (*this)[j] = i;
      }
    }
  }
  using T = long long int;
  // Prime factorization for x <= MAXN^2
  // Complexity: O(log x)          (x <= MAXN)
  //             O(MAXN / logMAXN) (MAXN < x <= MAXN^2)
  std::map<T, int> Factorize(T x) {
    assert(x <= 1LL * (int(size()) - 1) * (int(size()) - 1));
    std::map<T, int> ret;
    if (x < int(size())) {
      while (x > 1) {
        ret[(*this)[x]]++;
        x /= (*this)[x];
      }
    } else {
      for (auto p : primes) {
        while (!(x % p))
          x /= p, ret[p]++;
        if (x == 1)
          break;
      }
      if (x > 1)
        ret[x]++;
    }
    return ret;
  }
  std::vector<T> Divisors(T x) {
    std::vector<T> ret{1};
    for (auto p : Factorize(x)) {
      int n = ret.size();
      for (int i = 0; i < n; i++) {
        for (T a = 1, d = 1; d <= p.second; d++) {
          a *= p.first;
          ret.push_back(ret[i] * a);
        }
      }
    }
    return ret; // Not sorted
  }
  // Moebius function Table
  // return: [0=>0, 1=>1, 2=>-1, 3=>-1, 4=>0, 5=>-1, 6=>1, 7=>-1, 8=>0, ...]
  std::vector<int> GenerateMoebiusFunctionTable() {
    std::vector<int> ret(size());
    for (int i = 1; i < int(size()); i++) {
      if (i == 1)
        ret[i] = 1;
      else if ((i / (*this)[i]) % (*this)[i] == 0)
        ret[i] = 0;
      else
        ret[i] = -ret[i / (*this)[i]];
    }
    return ret;
  }
};
SieveOfEratosthenes sieve(1000000);

int main() {
  int N;
  cin >> N;
  ll ans = 0;
  for (int i = 1; i < N; ++i) {
    int tmp = N - i;
    auto x = sieve.Divisors(tmp);
    ans += x.size();
  }
  cout << ans << endl;
}


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

typedef long long ll;
typedef unsigned long long ull;
const long double PI = (acos(-1));
const long long MOD = 1000000007;
struct Edge {
  long long to;
  long long cost;
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, ll>;
const long long INF = 1LL << 60;
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) for (int i = 0; i < n; i++)

bool is_prime(ll x) {
  if (x == 1) {
    return false;
  }
  for (ll i = 2; i * i <= x; i++) {
    if (x % i == 0)
      return false;
  }
  return true;
}

long long modpow(long long a, long long n, long long mod) {
  long long res = 1;
  while (n > 0) {
    if (n & 1)
      res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}

long long combi(long long n, long long a) {
  long long ans = 1, ans1 = 1;
  for (long long i = n - a + 1; i <= n; i++) {
    ans *= i % MOD;
    ans %= MOD;
  }

  for (long long i = 2; i <= a; i++)
    ans1 = (ans1 * i) % MOD;
  ans1 = modpow(ans1, MOD - 2, MOD);
  return ((ans % MOD) * ans1) % MOD;
}

template <typename T>
bool next_combination(const T first, const T last, int k) {
  const T subset = first + k;
  // empty container | k = 0 | k == n
  if (first == last || first == subset || last == subset) {
    return false;
  }
  T src = subset;
  while (first != src) {
    src--;
    if (*src < *(last - 1)) {
      T dest = subset;
      while (*src >= *dest) {
        dest++;
      }
      iter_swap(src, dest);
      rotate(src + 1, dest + 1, last);
      rotate(subset, subset + (last - dest) - 1, last);
      return true;
    }
  }
  // restore
  rotate(first, subset, last);
  return false;
}

void dfs(vector<ll> s, ll mi, ll mx, ll N, vector<vector<ll>> &arr) {
  if (s.size() == (size_t)N) {
    // cout << s.c_str() << endl;
    arr.push_back(s);
  } else {
    for (ll c = s.size() > 0 ? 0 : mi; c <= mx; c++) {
      s.push_back(c);
      dfs(s, mi, mx, N, arr);
      s.pop_back();
    }
  }

  return;
}

int bfs(int sx, int sy, int gx, int gy, int h, int w,
        vector<vector<char>> map) {
  queue<pair<int, int>> s;

  vector<vector<ll>> ans;

  for (int i = 0; i < h; i++) {
    vector<ll> aa(w);
    ans.push_back(aa);
  }

  s.push(make_pair(sx, sy));
  while (s.size() > 0) {

    pair<int, int> tmp = s.front();
    s.pop();
    map[tmp.first][tmp.second] = '#';
    for (int i = -1; i <= 1; i++) {
      for (int j = -1; j <= 1; j++) {
        if (tmp.first + i < 0 || tmp.first + i >= h) {
          continue;
        }
        if (tmp.second + j < 0 || tmp.second + j >= w) {
          continue;
        }
        if (i != 0 && j != 0) {
          continue;
        }
        if (i == 0 && j == 0) {
          continue;
        }
        if (map[tmp.first + i][tmp.second + j] == '#') {
          continue;
        }
        map[tmp.first + i][tmp.second + j] = '#';
        if (ans[tmp.first + i][tmp.second + j] == 0) {
          ans[tmp.first + i][tmp.second + j] = ans[tmp.first][tmp.second] + 1;
        } else {
          ans[tmp.first + i][tmp.second + j] =
              min(ans[tmp.first + i][tmp.second + j],
                  ans[tmp.first][tmp.second] + 1);
        }
        s.push(make_pair(tmp.first + i, tmp.second + j));
      }
    }
  }

  return ans[gy][gx];
}

ll modfactorial(ll a) {
  if (a == 1)
    return 1;

  return (a % MOD) * (modfactorial(a - 1) % MOD);
}

ll gcd(ll a, ll b) {
  if (a % b == 0) {
    return (b);
  } else {
    return (gcd(b, a % b));
  }
}

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

map<ll, ll> prime_factor(ll n) {
  map<ll, ll> ret;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      ret[i]++;
      n /= i;
    }
  }
  if (n != 1)
    ret[n] = 1;
  return ret;
}

struct UnionFind {
  // 自身が親であれば、その集合に属する頂点数に-1を掛けたもの
  // そうでなければ親のid
  vector<int> r;

  UnionFind(int N) { r = vector<int>(N, -1); }

  int root(int x) {
    if (r[x] < 0)
      return x;
    return r[x] = root(r[x]);
  }

  bool unite(int x, int y) {
    x = root(x);
    y = root(y);
    if (x == y)
      return false;
    if (r[x] > r[y])
      swap(x, y);
    r[x] += r[y];
    r[y] = x;
    return true;
  }

  int size(int x) { return -r[root(x)]; }
};

/* dijkstra(G,s,dis)
    入力：グラフ G, 開始点 s, 距離を格納する dis
    計算量：O(|E|log|V|)
    副作用：dis が書き換えられる
*/
void dijkstra(const Graph &G, int s, vector<ll> &dis, vector<ll> &prev) {
  int N = G.size();
  dis.resize(N, INF);
  prev.resize(N, -1); // 初期化
  priority_queue<P, vector<P>, greater<P>> pq;
  dis[s] = 0;
  pq.emplace(dis[s], s);
  while (!pq.empty()) {
    P p = pq.top();
    pq.pop();
    int v = p.second;
    if (dis[v] < p.first) {
      continue;
    }
    for (auto &e : G[v]) {
      if (dis[e.to] > dis[v] + e.cost) {
        dis[e.to] = dis[v] + e.cost;
        prev[e.to] = v; // 頂点 v を通って e.to にたどり着いた
        pq.emplace(dis[e.to], e.to);
      }
    }
  }
}

vector<ll> get_path(const vector<ll> &prev, ll t) {
  vector<ll> path;
  for (ll cur = t; cur != -1; cur = prev[cur]) {
    path.push_back(cur);
  }
  reverse(path.begin(), path.end()); // 逆順なのでひっくり返す
  return path;
}

vector<string> split(string &s, char delim) {
  vector<string> elems;
  stringstream ss(s);
  string item;
  while (getline(ss, item, delim)) {
    if (!item.empty()) {
      elems.push_back(item);
    }
  }
  return elems;
}

vector<ll> divisor(ll n) {
  vector<ll> ret;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

void rgcd(int a, int b, ll counter) {
  if (counter == 0) {
    cout << a << " " << b << endl;
    return;
  }

  return rgcd(a, a + b, --counter);
}

template <class T> void divisor_transform(std::vector<T> &a) {
  int n = a.size();
  std::vector<bool> sieve(n, true);
  for (int p = 2; p < n; ++p) {
    if (sieve[p]) {
      for (int k = 1; k * p < n; ++k) {
        sieve[k * p] = false;
        a[k * p] += a[k];
      }
    }
  }
}

int main() {
  ll n;

  cin >> n;

  ll ans = 0;

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

    auto aa = divisor(tmp);
    ans += aa.size();
  }

  cout << ans << endl;

  return 0;
}
// cout << std::fixed << std::setprecision(15)

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

typedef long long ll;
typedef unsigned long long ull;
const long double PI = (acos(-1));
const long long MOD = 1000000007;
struct Edge {
  long long to;
  long long cost;
};
using Graph = vector<vector<Edge>>;
using P = pair<ll, ll>;
const long long INF = 1LL << 60;
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) for (int i = 0; i < n; i++)

bool is_prime(ll x) {
  if (x == 1) {
    return false;
  }
  for (ll i = 2; i * i <= x; i++) {
    if (x % i == 0)
      return false;
  }
  return true;
}

long long modpow(long long a, long long n, long long mod) {
  long long res = 1;
  while (n > 0) {
    if (n & 1)
      res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}

long long combi(long long n, long long a) {
  long long ans = 1, ans1 = 1;
  for (long long i = n - a + 1; i <= n; i++) {
    ans *= i % MOD;
    ans %= MOD;
  }

  for (long long i = 2; i <= a; i++)
    ans1 = (ans1 * i) % MOD;
  ans1 = modpow(ans1, MOD - 2, MOD);
  return ((ans % MOD) * ans1) % MOD;
}

template <typename T>
bool next_combination(const T first, const T last, int k) {
  const T subset = first + k;
  // empty container | k = 0 | k == n
  if (first == last || first == subset || last == subset) {
    return false;
  }
  T src = subset;
  while (first != src) {
    src--;
    if (*src < *(last - 1)) {
      T dest = subset;
      while (*src >= *dest) {
        dest++;
      }
      iter_swap(src, dest);
      rotate(src + 1, dest + 1, last);
      rotate(subset, subset + (last - dest) - 1, last);
      return true;
    }
  }
  // restore
  rotate(first, subset, last);
  return false;
}

void dfs(vector<ll> s, ll mi, ll mx, ll N, vector<vector<ll>> &arr) {
  if (s.size() == (size_t)N) {
    // cout << s.c_str() << endl;
    arr.push_back(s);
  } else {
    for (ll c = s.size() > 0 ? 0 : mi; c <= mx; c++) {
      s.push_back(c);
      dfs(s, mi, mx, N, arr);
      s.pop_back();
    }
  }

  return;
}

int bfs(int sx, int sy, int gx, int gy, int h, int w,
        vector<vector<char>> map) {
  queue<pair<int, int>> s;

  vector<vector<ll>> ans;

  for (int i = 0; i < h; i++) {
    vector<ll> aa(w);
    ans.push_back(aa);
  }

  s.push(make_pair(sx, sy));
  while (s.size() > 0) {

    pair<int, int> tmp = s.front();
    s.pop();
    map[tmp.first][tmp.second] = '#';
    for (int i = -1; i <= 1; i++) {
      for (int j = -1; j <= 1; j++) {
        if (tmp.first + i < 0 || tmp.first + i >= h) {
          continue;
        }
        if (tmp.second + j < 0 || tmp.second + j >= w) {
          continue;
        }
        if (i != 0 && j != 0) {
          continue;
        }
        if (i == 0 && j == 0) {
          continue;
        }
        if (map[tmp.first + i][tmp.second + j] == '#') {
          continue;
        }
        map[tmp.first + i][tmp.second + j] = '#';
        if (ans[tmp.first + i][tmp.second + j] == 0) {
          ans[tmp.first + i][tmp.second + j] = ans[tmp.first][tmp.second] + 1;
        } else {
          ans[tmp.first + i][tmp.second + j] =
              min(ans[tmp.first + i][tmp.second + j],
                  ans[tmp.first][tmp.second] + 1);
        }
        s.push(make_pair(tmp.first + i, tmp.second + j));
      }
    }
  }

  return ans[gy][gx];
}

ll modfactorial(ll a) {
  if (a == 1)
    return 1;

  return (a % MOD) * (modfactorial(a - 1) % MOD);
}

ll gcd(ll a, ll b) {
  if (a % b == 0) {
    return (b);
  } else {
    return (gcd(b, a % b));
  }
}

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

map<ll, ll> prime_factor(ll n) {
  map<ll, ll> ret;
  for (ll i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      ret[i]++;
      n /= i;
    }
  }
  if (n != 1)
    ret[n] = 1;
  return ret;
}

struct UnionFind {
  // 自身が親であれば、その集合に属する頂点数に-1を掛けたもの
  // そうでなければ親のid
  vector<int> r;

  UnionFind(int N) { r = vector<int>(N, -1); }

  int root(int x) {
    if (r[x] < 0)
      return x;
    return r[x] = root(r[x]);
  }

  bool unite(int x, int y) {
    x = root(x);
    y = root(y);
    if (x == y)
      return false;
    if (r[x] > r[y])
      swap(x, y);
    r[x] += r[y];
    r[y] = x;
    return true;
  }

  int size(int x) { return -r[root(x)]; }
};

/* dijkstra(G,s,dis)
    入力：グラフ G, 開始点 s, 距離を格納する dis
    計算量：O(|E|log|V|)
    副作用：dis が書き換えられる
*/
void dijkstra(const Graph &G, int s, vector<ll> &dis, vector<ll> &prev) {
  int N = G.size();
  dis.resize(N, INF);
  prev.resize(N, -1); // 初期化
  priority_queue<P, vector<P>, greater<P>> pq;
  dis[s] = 0;
  pq.emplace(dis[s], s);
  while (!pq.empty()) {
    P p = pq.top();
    pq.pop();
    int v = p.second;
    if (dis[v] < p.first) {
      continue;
    }
    for (auto &e : G[v]) {
      if (dis[e.to] > dis[v] + e.cost) {
        dis[e.to] = dis[v] + e.cost;
        prev[e.to] = v; // 頂点 v を通って e.to にたどり着いた
        pq.emplace(dis[e.to], e.to);
      }
    }
  }
}

vector<ll> get_path(const vector<ll> &prev, ll t) {
  vector<ll> path;
  for (ll cur = t; cur != -1; cur = prev[cur]) {
    path.push_back(cur);
  }
  reverse(path.begin(), path.end()); // 逆順なのでひっくり返す
  return path;
}

vector<string> split(string &s, char delim) {
  vector<string> elems;
  stringstream ss(s);
  string item;
  while (getline(ss, item, delim)) {
    if (!item.empty()) {
      elems.push_back(item);
    }
  }
  return elems;
}

vector<ll> divisor(ll n) {
  vector<ll> ret;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

int main() {
  ll n;

  cin >> n;

  ll ans = 0;

  for (int i = 1; i < n; i++) {
    ans += (n - 1) / i;
  }

  cout << ans << endl;

  return 0;
}
// cout << std::fixed << std::setprecision(15)


#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;

int main() {
  int n;
  cin >> n;
  int ans = 0;

  rep(i, n - 1) {
    int a = n - (i + 1);
    int cnt = 0;
    rep(j, (int)(sqrt(a) + 1e-9)) {
      if (a % (j + 1) == 0) {
        cnt++;
        if (a != (j + 1) * (j + 1))
          cnt++;
      }
    }
    ans += cnt;
  }
  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;

int main() {
  int n;
  cin >> n;
  int ans = 0;

  rep(i, n - 1) {
    int a = n - (i + 1);
    int s = sqrt(a);
    int cnt = 0;
    // rep(j, (int)(sqrt(a) + 1e-9)+1){
    for (int j = 1; j < s + 1e-9; j++)
      if (a % j == 0)
        cnt += 2;
    if (s * s == a)
      cnt--;
    ans += cnt;
  }
  cout << ans << endl;
  return 0;
}


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

// g++ -std=c++17 -Wshadow -Wall -g -fsanitize=address -fsanitize=undefined
// -D_GLIBCXX_DEBUG -o

vector<bool> Sieve(1000005, true);
void sieve() {
  Sieve[0] = false;
  Sieve[1] = false;
  for (ll i = 2; i * i <= 1000000; i++) {
    if (Sieve[i] == true) {
      for (ll j = i * i; j <= 1000000; j += i) {
        Sieve[j] = false;
      }
    }
  }
}
ll getDiv(ll n) {
  ll res = 0;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      res++;
      if (n / i != i)
        res++;
    }
  }
  return res;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  ll gd[100001] = {0};
  for (int i = 1; i <= 100000; i++) {
    gd[i] = gd[i - 1] + getDiv(i);
  }
  ll n;
  cin >> n;
  ll ans = 0;
  //  for(int i=0;i<n;i++)cout<<i<<" "<<Sieve[i]<<"\\n";
  if (n <= 100000) {
    cout << gd[n - 1] << "\\n";
    return 0;
  }
  ans = gd[100000];
  for (int i = 100001; i < n; i++) {
    ans += getDiv(i);
  }
  cout << ans << "\\n";
  return 0;
}

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

// g++ -std=c++17 -Wshadow -Wall -g -fsanitize=address -fsanitize=undefined
// -D_GLIBCXX_DEBUG -o

vector<bool> Sieve(1000005, true);
void sieve() {
  Sieve[0] = false;
  Sieve[1] = false;
  for (ll i = 2; i * i <= 1000000; i++) {
    if (Sieve[i] == true) {
      for (ll j = i * i; j <= 1000000; j += i) {
        Sieve[j] = false;
      }
    }
  }
}
ll getDiv(ll n) {
  ll res = 0;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      res++;
      if (n / i != i)
        res++;
    }
  }
  return res;
}
int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  n--;
  for (int i = 1; i <= n; i++)
    ans += (n / i);
  cout << ans << "\\n";
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define fastIO                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define ll long long int
#define fi first
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define repd(i, l, r) for (int i = (int)(l); i >= (int)(r); i--)
void SieveOfEratosthenes(int n, bool prime[], bool primesquare[], int 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 (int 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 (int i = 0; i <= (n * n + 1); i++)
    primesquare[i] = false;

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

  for (int 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 (int i = p * 2; i <= n; i += p)
        prime[i] = false;
    }
  }

  int j = 0;
  for (int 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
int countDivisors(int 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];

  int 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
  int ans = 1;

  // Loop for counting factors of n
  for (int 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
}
int32_t main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  fastIO;
  ll t, n, i, j, a, c, d, k, q, l, r, x, y;
  // cin>>t;
  t = 1;
  while (t--) {
    cin >> n;
    ll cnt = 0;
    for (i = 1; i < n; i++) {
      ll num = n - i;
      cnt += countDivisors(num);
    }
    cout << cnt;
  }

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define fastIO                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define ll long long int
#define fi first
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define repd(i, l, r) for (int i = (int)(l); i >= (int)(r); i--)
const int MAX = 1000001;

// array to store prime factors
int factor[MAX] = {0};

// function to generate all prime factors
// of numbers from 1 to 10^6
void generatePrimeFactors() {
  factor[1] = 1;

  // Initializes all the positions with their value.
  for (int i = 2; i < MAX; i++)
    factor[i] = i;

  // Initializes all multiples of 2 with 2
  for (int i = 4; i < MAX; i += 2)
    factor[i] = 2;

  // A modified version of Sieve of Eratosthenes to
  // store the smallest prime factor that divides
  // every number.
  for (int i = 3; i * i < MAX; i++) {
    // check if it has no prime factor.
    if (factor[i] == i) {
      // Initializes of j starting from i*i
      for (int j = i * i; j < MAX; j += i) {
        // if it has no prime factor before, then
        // stores the smallest prime divisor
        if (factor[j] == j)
          factor[j] = i;
      }
    }
  }
}
int calculateNoOFactors(int n) {
  if (n == 1)
    return 1;

  int ans = 1;

  // stores the smallest prime number
  // that divides n
  int dup = factor[n];

  // stores the count of number of times
  // a prime number divides n.
  int c = 1;

  // reduces to the next number after prime
  // factorization of n
  int j = n / factor[n];

  // false when prime factorization is done
  while (j != 1) {
    // if the same prime number is dividing n,
    // then we increase the count
    if (factor[j] == dup)
      c += 1;

    /* if its a new prime factor that is factorizing n,
       then we again set c=1 and change dup to the new
       prime factor, and apply the formula explained
       above. */
    else {
      dup = factor[j];
      ans = ans * (c + 1);
      c = 1;
    }

    j = j / factor[j];
  }

  ans = ans * (c + 1);

  return ans;
}

int32_t main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  fastIO;
  ll t, n, i, j, a, c, d, k, q, l, r, x, y;
  // cin>>t;
  t = 1;
  while (t--) {
    generatePrimeFactors();
    cin >> n;
    ll cnt = 0;
    for (i = 1; i < n; i++) {
      ll num = n - i;
      cnt += calculateNoOFactors(num);
    }
    cout << cnt;
  }

  return 0;
}


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

int main() {
  int n;
  cin >> n;
  int a, b, c;
  int ab;
  int m = 0;
  for (c = 1; c < n; ++c) {
    ab = n - c;
    for (a = 1; a * a <= ab; ++a) {
      b = ab / a;
      if (a * b == ab) {
        m += 2;
        if (a == b)
          m--;
      }
    }
  }
  cout << m << endl;
}

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

int main() {
  int n;
  cin >> n;
  int a, b, c;
  int ab;
  int m = 0;
  for (c = 1; c < n; ++c) {
    for (a = 1; a * a <= c; ++a) {
      b = c / a;
      if (a * b == c) {
        m += 2;
        if (a == b)
          m--;
      }
    }
  }
  cout << m << endl;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;

#define sz(a) int((a).size())
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define ini(a, i) memset(a, i, sizeof(a))
#define inin(a, n, i) memset(a, i, sizeof(a[0]) * (n))
#define contains(c, i) ((c).find(i) != (c).end())
#define present(i, c) (find(all(c), i) != (c).end())

#define trav(x, c) for (auto &x : c)
#define rep(i, n) for (int i = 0; i < n; i++)
#define repa(i, b, e)                                                          \\
  for (int i = (b) - ((b) > (e)); i != (e) - ((b) > (e));                      \\
       i += 1 - 2 * ((b) > (e)))

template <class T> bool chkmax(T &x, T y) {
  return x < y ? x = y, true : false;
}
template <class T> bool chkmin(T &x, T y) {
  return x > y ? x = y, true : false;
}
template <class A, class B> A cvt(B x) {
  stringstream s;
  s << x;
  A r;
  s >> r;
  return r;
}

void read() {}
void print() {}
template <class T, class... Args> void read(T &a, Args &...args) {
  cin >> a;
  read(args...);
}
template <class T, class... Args> void print(T a, Args... args) {
  cout << a << ' ';
  print(args...);
}
template <class... Args> void println(Args... args) {
  print(args...);
  cout << '\\n';
}

#define debug(args...)                                                         \\
  {                                                                            \\
    string s_(#args);                                                          \\
    replace(all(s_), ',', ' ');                                                \\
    stringstream ss_(s_);                                                      \\
    istream_iterator<string> it_(ss_);                                         \\
    cerr_(it_, args);                                                          \\
  }
void cerr_(istream_iterator<string> it) { (void)it; }
template <class T, class... Args>
void cerr_(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << endl;
  cerr_(++it, args...);
}

template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  os << '{';
  string sep;
  for (const auto &x : v)
    os << sep << x, sep = ", ";
  return os << '}';
}
template <class T> ostream &operator<<(ostream &os, const set<T> &s) {
  os << '{';
  string sep;
  for (const auto &x : s)
    os << sep << x, sep = ", ";
  return os << '}';
}
template <class T, class S>
ostream &operator<<(ostream &os, const map<T, S> &m) {
  os << '{';
  string sep;
  for (const auto &x : m)
    os << sep << x, sep = ", ";
  return os << '}';
}
template <class T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
  os << '{';
  string sep;
  for (const auto &x : arr)
    os << sep << x, sep = ", ";
  return os << '}';
}

const int INF = 0x3F3F3F3F;
const int MAXN = (int)1e6;
const int MOD = (int)1e9 + 7;

//=========================

void run_test() {
  ll n;
  read(n);
  int ans = 0;
  for (int c = 1; c < n; c++) {
    int sq = sqrt(n - c) + 1;
    for (int a = 1; a <= sq; a++) {
      int b = (n - c) / a;
      if (b < a)
        break;
      if (a * b + c == n) {
        ans += 2;
        if (a == b)
          ans--;
      }
    }
  }
  println(ans);
}

//=========================

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  // int t_ = 1, t__; cin >> t__; while(t_ <= t__) { cout << "Case #" << t_++ <<
  // ": "; run_test(); }
  //  int t_; cin >> t_; while(t_--) run_test();
  run_test();
  return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;

#define sz(a) int((a).size())
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define ini(a, i) memset(a, i, sizeof(a))
#define inin(a, n, i) memset(a, i, sizeof(a[0]) * (n))
#define contains(c, i) ((c).find(i) != (c).end())
#define present(i, c) (find(all(c), i) != (c).end())

#define trav(x, c) for (auto &x : c)
#define rep(i, n) for (int i = 0; i < n; i++)
#define repa(i, b, e)                                                          \\
  for (int i = (b) - ((b) > (e)); i != (e) - ((b) > (e));                      \\
       i += 1 - 2 * ((b) > (e)))

template <class T> bool chkmax(T &x, T y) {
  return x < y ? x = y, true : false;
}
template <class T> bool chkmin(T &x, T y) {
  return x > y ? x = y, true : false;
}
template <class A, class B> A cvt(B x) {
  stringstream s;
  s << x;
  A r;
  s >> r;
  return r;
}

void read() {}
void print() {}
template <class T, class... Args> void read(T &a, Args &...args) {
  cin >> a;
  read(args...);
}
template <class T, class... Args> void print(T a, Args... args) {
  cout << a << ' ';
  print(args...);
}
template <class... Args> void println(Args... args) {
  print(args...);
  cout << '\\n';
}

#define debug(args...)                                                         \\
  {                                                                            \\
    string s_(#args);                                                          \\
    replace(all(s_), ',', ' ');                                                \\
    stringstream ss_(s_);                                                      \\
    istream_iterator<string> it_(ss_);                                         \\
    cerr_(it_, args);                                                          \\
  }
void cerr_(istream_iterator<string> it) { (void)it; }
template <class T, class... Args>
void cerr_(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << endl;
  cerr_(++it, args...);
}

template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
  os << '{';
  string sep;
  for (const auto &x : v)
    os << sep << x, sep = ", ";
  return os << '}';
}
template <class T> ostream &operator<<(ostream &os, const set<T> &s) {
  os << '{';
  string sep;
  for (const auto &x : s)
    os << sep << x, sep = ", ";
  return os << '}';
}
template <class T, class S>
ostream &operator<<(ostream &os, const map<T, S> &m) {
  os << '{';
  string sep;
  for (const auto &x : m)
    os << sep << x, sep = ", ";
  return os << '}';
}
template <class T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
  os << '{';
  string sep;
  for (const auto &x : arr)
    os << sep << x, sep = ", ";
  return os << '}';
}

const int INF = 0x3F3F3F3F;
const int MAXN = (int)1e6;
const int MOD = (int)1e9 + 7;

//=========================

void run_test() {
  ll n;
  read(n);
  int ans = 0;
  for (int a = 1; a < n; a++)
    ans += (n - 1) / a;
  println(ans);
}

//=========================

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  // int t_ = 1, t__; cin >> t__; while(t_ <= t__) { cout << "Case #" << t_++ <<
  // ": "; run_test(); }
  //  int t_; cin >> t_; while(t_--) run_test();
  run_test();
  return 0;
}


#include <bits/stdc++.h>
#define fast                                                                   \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL)
#define ll long long int
#define ld long double
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;

int main() {
  fast;
  ll n, ans = 0;
  cin >> n;
  for (int i = 1; i < n; ++i) {
    ll x = n - i;
    for (int j = 1; j <= sqrt(x); ++j) {
      if (x % j == 0) {
        ++ans;
        if (x / j != x / (x / j))
          ++ans;
      }
    }
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
#define fast                                                                   \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL)
#define ll long long int
#define ld long double
using namespace std;
const int N = 1e6 + 1;
const int MOD = 1e9 + 7;
vector<ll> factors[N];

void sieve() {
  for (int i = 1; i < N; ++i)
    for (int j = i; j < N; j += i)
      factors[j].push_back(i);
}

int main() {
  fast;
  ll n, ans = 0;
  cin >> n;
  sieve();
  for (int i = 1; i < n; ++i) {
    ll x = n - i;
    ans += factors[x].size();
  }
  cout << ans;
  cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \\n";
  return 0;
}


#include "bits/stdc++.h"
#include <set>

using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define all(i) (i).begin(), (i).end()
#define rall(i) (i).begin(), (i).end(), greater<int>()
#define int long long
#define elif else if
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define fst first
#define sec second
#define mod 1000000007
#define INF 10e10
template <typename T>

void print(T x) {
  std::cout << x << " ";
}

template <typename T>

void println(T x) {
  std::cout << x << "\\n";
}

int enum_divisors(int N) {
  int res = 0;
  for (int i = 1; i * i <= N; ++i) {
    if (N % i == 0) {
      res++;
      // 重複しないならば i の相方である N/i も push
      if (N / i != i)
        res++;
    }
  }
  return res;
}
signed main(void) {
  int n;
  cin >> n;
  int ret = 0;
  rep1(i, n) { ret += enum_divisors(n - i); }
  print(ret);
}

#include "bits/stdc++.h"
#include <set>

using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define all(i) (i).begin(), (i).end()
#define rall(i) (i).begin(), (i).end(), greater<int>()
#define int long long
#define elif else if
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define fst first
#define sec second
#define mod 1000000007
#define INF 10e10
template <typename T>

void print(T x) {
  std::cout << x << " ";
}

template <typename T>

void println(T x) {
  std::cout << x << "\\n";
}

signed main(void) {
  int n;
  cin >> n;
  vector<int> a(n, 2);
  a[1] = 1;
  FOR(i, 2, n + 1) {
    for (int j = 2 * i; j <= n; j += i) {
      a[j]++;
    }
  }
  int ret = 0;
  rep1(i, n) { ret += a[n - i]; }
  print(ret);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define eb emplace_back
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define cinarr(A, len)                                                         \\
  for (int i = 0; i < len; i++) {                                              \\
    cin >> A[i];                                                               \\
  }
#define coutarr(A, len)                                                        \\
  for (int i = 0; i < len; i++) {                                              \\
    cout << A[i] << ' ';                                                       \\
  }                                                                            \\
  cout << endl
#define coutin(V)                                                              \\
  for (auto &i : V) {                                                          \\
    cout << i << ' ';                                                          \\
  }                                                                            \\
  cout << endl // for vect and set
#define coutmap(U)                                                             \\
  for (auto &i : U) {                                                          \\
    cout << i.first << "->" << i.second << ", ";                               \\
  }                                                                            \\
  cout << endl // for map
#define deb(x) cerr << #x << '\\t' << x << endl
const int imax = numeric_limits<int>::max(), imin = numeric_limits<int>::min();
const long long lmax = numeric_limits<long long>::max(),
                lmin = numeric_limits<long long>::min();
/*========================================================================*/
/* strategi/note:

/================================*/

bool Svd = 0;
void solve() {
  Svd = 1;
  ll n;
  cin >> n;
  ll ans = 0;
  ll to = ceil(sqrt(n));
  for (ll a = 1; a <= n; a++) {
    for (ll b = 1; b <= n; b++) {
      if (a * b < n) {
        // cout << a << ' ' << b << ' ' << n-a*b << endl;
        ans++;
      }
    }
  }
  cout << ans << endl;
}

/*========================================================================*/

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  // cout<<fixed<<setprecision( ); // iomanip **

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

  if (!Svd)
    cout << "solve() function blm dipanggil!" << endl;
  // cout.flush(); cin.get();
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define eb emplace_back
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define cinarr(A, len)                                                         \\
  for (int i = 0; i < len; i++) {                                              \\
    cin >> A[i];                                                               \\
  }
#define coutarr(A, len)                                                        \\
  for (int i = 0; i < len; i++) {                                              \\
    cout << A[i] << ' ';                                                       \\
  }                                                                            \\
  cout << endl
#define coutin(V)                                                              \\
  for (auto &i : V) {                                                          \\
    cout << i << ' ';                                                          \\
  }                                                                            \\
  cout << endl // for vect and set
#define coutmap(U)                                                             \\
  for (auto &i : U) {                                                          \\
    cout << i.first << "->" << i.second << ", ";                               \\
  }                                                                            \\
  cout << endl // for map
#define deb(x) cerr << #x << '\\t' << x << endl
const int imax = numeric_limits<int>::max(), imin = numeric_limits<int>::min();
const long long lmax = numeric_limits<long long>::max(),
                lmin = numeric_limits<long long>::min();
/*========================================================================*/
/* strategi/note:

/================================*/

bool Svd = 0;
void solve() {
  Svd = 1;
  ll n;
  cin >> n;
  ll ans = 0;
  for (ll a = 1; a <= n; a++) {
    // cout << a << ' ' << b << ' ' << n-a*b << endl;
    ans += (n / a) - (n % a == 0 ? 1 : 0);
  }
  cout << ans << endl;
}

/*========================================================================*/

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  // cout<<fixed<<setprecision( ); // iomanip **

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

  if (!Svd)
    cout << "solve() function blm dipanggil!" << endl;
  // cout.flush(); cin.get();
  return 0;
}


#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using ll = long long;
using vec = vector<ll>;
using vec2 = vector<vector<ll>>;
ll inf = pow(2, 62);

ll yakusuu(ll x) {
  ll sum = 0;
  for (int i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      sum += 1;
      if (i * i != x) {
        sum++;
      }
    }
  }
  // 約数の個数
  return sum;
}

int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  for (int c = 1; c < n; c++) {
    ans += yakusuu(n - c);
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using ll = long long;
using vec = vector<ll>;
using vec2 = vector<vector<ll>>;
ll inf = pow(2, 62);

ll yakusuu(ll x) {
  ll sum = 0;
  for (int i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      sum += 1;
      if (i * i != x) {
        sum++;
      }
    }
  }
  // 約数の個数
  return sum;
}

int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  /*for(int c = 1;c < n;c++){
      ans += yakusuu(n-c);
  }*/
  for (int a = 1; a < n; a++) {
    if (n % a == 0) {
      ans += (n / a) - 1;
    } else {
      ans += n / a;
    }
  }
  cout << ans << endl;
}


#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

using namespace std;

using i64 = long long;
#define forn(a, e) for (i64 a = 0; a < (i64)(e); a++)
#define forr(a, s, e) for (i64 a = s; a < (i64)(e); a++)
#define fore(e, a) for (auto &e : a)

#ifdef LOCAL
#define logv(a)                                                                \\
  {                                                                            \\
    cerr << #a << " = ";                                                       \\
    fore(e, a) { cerr << e << " "; }                                           \\
    cerr << "\\n";                                                              \\
  }
#define logvp(a)                                                               \\
  {                                                                            \\
    cerr << #a << " = ";                                                       \\
    fore(e, a) { cerr << "(" << e.first << ", " << e.second << ") "; }         \\
    cerr << "\\n";                                                              \\
  }
#define logvv(a)                                                               \\
  {                                                                            \\
    cerr << #a << " = \\n";                                                     \\
    fore(r, a) {                                                               \\
      fore(e, r) { cerr << e << " "; }                                         \\
      cerr << "\\n";                                                            \\
    }                                                                          \\
  }
#define logvf(a, field)                                                        \\
  {                                                                            \\
    cerr << #a "." #field << " = \\n";                                          \\
    fore(e, a) { cerr << e.field << " "; }                                     \\
    cerr << "\\n";                                                              \\
  }
#define logvff(a, f1, f2)                                                      \\
  {                                                                            \\
    cerr << #a ".{" #f1 << ", " #f2 << "} = \\n";                               \\
    fore(e, a) { cerr << "(" << e.f1 << ", " << e.f2 << ") "; }                \\
    cerr << "\\n";                                                              \\
  }
#define logs(a) cerr << #a << " = " << (a) << "\\n";
#define logss(a, b)                                                            \\
  cerr << #a << " = " << (a) << ", " << #b << " = " << (b) << "\\n";
#define logp(a)                                                                \\
  cerr << #a << " = "                                                          \\
       << "(" << a.first << ", " << a.second << ")"                            \\
       << "\\n";
#define cond(pred, stmt)                                                       \\
  if (pred) {                                                                  \\
    stmt                                                                       \\
  }
#else
#define logv(a)
#define logvp(a)
#define logvv(a)
#define logvf(a, field)
#define logvff(a, f1, f2)
#define logs(a)
#define logss(a, b)
#define logp(a)
#define cond(pred, stmt)
#endif

using iip = pair<int, int>;
using llp = pair<i64, i64>;
using ivec = vector<int>;
using llvec = vector<i64>;
using svec = vector<string>;
template <typename T> using vec = vector<T>;

template <typename T, typename Dim> auto make_vec(T value, Dim dim) {
  return vector<T>(dim, value);
}
template <typename T, typename Dim1, typename... Dim>
auto make_vec(T value, Dim1 dim1, Dim... dims) {
  return make_vec(make_vec(value, dims...), dim1);
}

template <typename T> bool uax(T &v, const T &newv) {
  if (v < newv) {
    v = newv;
    return true;
  } else
    return false;
}
template <typename T> bool uin(T &v, const T &newv) {
  if (v > newv) {
    v = newv;
    return true;
  } else
    return false;
}

template <typename T> istream &operator>>(istream &is, vector<T> &c) {
  for (auto &e : c)
    is >> e;
  return is;
}
template <typename T, size_t N>
istream &operator>>(istream &is, array<T, N> &c) {
  for (auto &e : c)
    is >> e;
  return is;
}

template <typename... T> istream &read(T &...args) {
  return (cin >> ... >> args);
}

static mt19937 rande(123123);
template <typename T> T rand_int(T from, T to) {
  uniform_int_distribution<T> distr(from, to);
  return distr(rande);
}

// const i64 INF = 1e18;
const int INF = 2e9;
const i64 M = 1e9 + 7;
const int MXB = 20;
using bin = bitset<MXB + 1>;

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  rande.seed(chrono::steady_clock::now().time_since_epoch().count());

  int n;
  while (read(n)) {
    i64 ans = 0;
    forr(c, 1, n) {
      i64 ab = n - c;
      for (i64 i = 1; i * i <= ab; i++) {
        if (ab % i == 0) {
          if (i * i == ab) {
            ans++;
          } else {
            ans += 2;
          }
        }
      }
    }
    cout << ans << endl;
  }
}

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

using namespace std;

using i64 = long long;
#define forn(a, e) for (i64 a = 0; a < (i64)(e); a++)
#define forr(a, s, e) for (i64 a = s; a < (i64)(e); a++)
#define fore(e, a) for (auto &e : a)

#ifdef LOCAL
#define logv(a)                                                                \\
  {                                                                            \\
    cerr << #a << " = ";                                                       \\
    fore(e, a) { cerr << e << " "; }                                           \\
    cerr << "\\n";                                                              \\
  }
#define logvp(a)                                                               \\
  {                                                                            \\
    cerr << #a << " = ";                                                       \\
    fore(e, a) { cerr << "(" << e.first << ", " << e.second << ") "; }         \\
    cerr << "\\n";                                                              \\
  }
#define logvv(a)                                                               \\
  {                                                                            \\
    cerr << #a << " = \\n";                                                     \\
    fore(r, a) {                                                               \\
      fore(e, r) { cerr << e << " "; }                                         \\
      cerr << "\\n";                                                            \\
    }                                                                          \\
  }
#define logvf(a, field)                                                        \\
  {                                                                            \\
    cerr << #a "." #field << " = \\n";                                          \\
    fore(e, a) { cerr << e.field << " "; }                                     \\
    cerr << "\\n";                                                              \\
  }
#define logvff(a, f1, f2)                                                      \\
  {                                                                            \\
    cerr << #a ".{" #f1 << ", " #f2 << "} = \\n";                               \\
    fore(e, a) { cerr << "(" << e.f1 << ", " << e.f2 << ") "; }                \\
    cerr << "\\n";                                                              \\
  }
#define logs(a) cerr << #a << " = " << (a) << "\\n";
#define logss(a, b)                                                            \\
  cerr << #a << " = " << (a) << ", " << #b << " = " << (b) << "\\n";
#define logp(a)                                                                \\
  cerr << #a << " = "                                                          \\
       << "(" << a.first << ", " << a.second << ")"                            \\
       << "\\n";
#define cond(pred, stmt)                                                       \\
  if (pred) {                                                                  \\
    stmt                                                                       \\
  }
#else
#define logv(a)
#define logvp(a)
#define logvv(a)
#define logvf(a, field)
#define logvff(a, f1, f2)
#define logs(a)
#define logss(a, b)
#define logp(a)
#define cond(pred, stmt)
#endif

using iip = pair<int, int>;
using llp = pair<i64, i64>;
using ivec = vector<int>;
using llvec = vector<i64>;
using svec = vector<string>;
template <typename T> using vec = vector<T>;

template <typename T, typename Dim> auto make_vec(T value, Dim dim) {
  return vector<T>(dim, value);
}
template <typename T, typename Dim1, typename... Dim>
auto make_vec(T value, Dim1 dim1, Dim... dims) {
  return make_vec(make_vec(value, dims...), dim1);
}

template <typename T> bool uax(T &v, const T &newv) {
  if (v < newv) {
    v = newv;
    return true;
  } else
    return false;
}
template <typename T> bool uin(T &v, const T &newv) {
  if (v > newv) {
    v = newv;
    return true;
  } else
    return false;
}

template <typename T> istream &operator>>(istream &is, vector<T> &c) {
  for (auto &e : c)
    is >> e;
  return is;
}
template <typename T, size_t N>
istream &operator>>(istream &is, array<T, N> &c) {
  for (auto &e : c)
    is >> e;
  return is;
}

template <typename... T> istream &read(T &...args) {
  return (cin >> ... >> args);
}

static mt19937 rande(123123);
template <typename T> T rand_int(T from, T to) {
  uniform_int_distribution<T> distr(from, to);
  return distr(rande);
}

// const i64 INF = 1e18;
const int INF = 2e9;
const i64 M = 1e9 + 7;
const int MXB = 20;
using bin = bitset<MXB + 1>;

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  rande.seed(chrono::steady_clock::now().time_since_epoch().count());

  int n;
  while (read(n)) {
    i64 ans = 0;
    for (i64 a = 1; a * a < n; a++) {
      i64 d1 = (n - 1) / a;
      i64 d2 = a;
      i64 d = 2 * max(0ll, d1 - d2) + 1;
      ans += d;
    }
    cout << ans << endl;
  }
}


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

#ifdef BOI
#include "debug.h"
#else
#define debug(args...)
#endif

#define all(x) begin(x), end(x)
#define sz(x) (int)x.size()
#define eps 1e-7
#define inf 0x3f3f3f3f
#define endl '\\n'

int main() {
  cin.tie(0)->sync_with_stdio(0), cin.exceptions(cin.failbit);
  long long n;
  cin >> n;

  long long ans = 1;

  for (long long i = 2; i < n; ++i) {
    long long cnt = 0, bruh = 0;
    for (long long j = 1; j * j <= i; ++j) {
      if (i % j == 0) {
        if (i / j != j)
          cnt += 2;
        else
          cnt++, ++bruh;
      }
    }
    debug(i, cnt);
    ans += cnt;
  }

  cout << ans;
}

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

#ifdef BOI
#include "debug.h"
#else
#define debug(args...)
#endif

#define all(x) begin(x), end(x)
#define sz(x) (int)x.size()
#define eps 1e-7
#define inf 0x3f3f3f3f
#define endl '\\n'

int main() {
  cin.tie(0)->sync_with_stdio(0), cin.exceptions(cin.failbit);
  long long n;
  cin >> n;

  long long ans = 0;

  for (long long i = 1; i < n; ++i) {
    ans += ((n - 1) / i);
  }

  cout << ans;
}


#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, s, n) for (int i = (s); i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;

ll enum_counter(int n) {
  ll count = 0;
  for (int i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      count++;
      if (n / i != i)
        count++;
    }
  }
  return count;
}

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

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, s, n) for (int i = (s); i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;

template <typename T> vector<T> smallest_prime_factors(T n) {
  vector<T> spf(n + 1);
  for (int i = 0; i <= n; i++)
    spf[i] = i;

  for (T i = 2; i * i <= n; i++) {
    // 素数だったら
    if (spf[i] == i) {
      for (T j = i * i; j <= n; j += i) {
        // iを持つ整数かつまだ素数が決まっていないなら
        if (spf[j] == j) {
          spf[j] = i;
        }
      }
    }
  }

  return spf;
}

template <typename T> vector<T> factolization(T x, vector<T> &spf) {
  vector<T> ret;
  while (x != 1) {
    ret.push_back(spf[x]);
    x /= spf[x];
  }
  sort(ret.begin(), ret.end());
  return ret;
}

int main() {
  constexpr int MAX = 1000000;

  auto spf = smallest_prime_factors(MAX);

  int n;
  cin >> n;

  int ans = 0;
  for (int i = 1; i < n; i++) {
    int count = 1;
    map<int, int> mp;
    auto result = factolization(n - i, spf);
    for (auto z : result)
      mp[z]++;
    for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
      count *= itr->second + 1;
    }
    ans += count;
  }
  cout << ans << endl;
  return 0;
}


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

{
  int N;
  int a, b, c;
  int kount = 0;
  cin >> N;
  for (a = 1; a <= N; a++) {
    for (b = 1; b <= N; b++) {
      for (c = 1; c <= N; c++) {
        int sum = 0;
        sum = a * b + c;
        if (sum == N) {
          kount++;
        }
      }
    }
  }
  cout << kount << "\\n";
  return 0;
}

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;

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


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\\n'
#define mod 1000000007
#define pb push_back
#define ff first
#define ss second
#define con continue
#define ub upper_bound
#define lb lower_bound
#define sum(a) (accumulate((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) (min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) (max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) (lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) (upper_bound((a).begin(), (a).end(), (x)) - (a).begin())

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};

const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};

vector<ll> p;
void seive(ll x) {

  for (ll i = 2; i <= sqrt(x); ++i) {
    if (p[i] == -1) {
      p[i] = i;
      for (ll j = i * i; j <= x; j += i)
        p[j] = i;
    }
  }
}
unordered_map<int, int> m;
ll f(ll x) {
  m.clear();
  if (x == 1)
    return 1;
  ll ans = 1;
  ll c = 1;
  while (x != 1) {
    if (p[x] == -1) {
      m[x]++;
      break;
    }
    m[p[x]] = (m[p[x]] + 1) % mod;
    x /= p[x];
  }

  for (auto x : m) {
    auto a = x.ss;

    ans = (ans % mod * (a + 1) % mod) % mod;
  }

  return ans;
}

void solve() {
  ll n;
  cin >> n;

  ll ans = 0;
  p.clear();
  p.resize(n, -1);
  seive(n);

  for (ll i = 1; i <= n - 1; i++) {
    // cout << i << endl;

    ans += f(i);
  }
  cout << ans << endl;
}

int main() { solve(); }

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl '\\n'
#define mod 998244353
#define pb push_back
#define ff first
#define ss second
#define con continue
#define ub upper_bound
#define lb lower_bound
#define sum(a) (accumulate((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) (min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) (max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) (lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) (upper_bound((a).begin(), (a).end(), (x)) - (a).begin())

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};

const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};

// unordered_map<ll,ll> m1 ;
void solve() {

  ll n;
  cin >> n;
  vector<ll> arr(n + 1, 1);
  for (ll i = 1; i <= n; i++) {
    for (ll j = i * 2; j <= n; j += i)
      arr[j]++;
  }
  ll ans = 0;
  for (ll j = 1; j < n; j++)
    ans += arr[j];
  cout << ans << endl;
}

// cout << arr2[n-1]<< endl;

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  solve();
}


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

int power(int x, int n) {
  if (x == 0)
    return 0;
  if (n == 0)
    return 1;
  if (n == 1)
    return x;
  int res = power(x, n / 2);
  res = (res * res) % mod;
  if (n % 2)
    return (res * x) % mod;
  return res;
}

int nCr(int n, int r) {
  if (r == 0)
    return 1;
  vector<int> f(n + 1);
  f[0] = 1;
  for (int i = 1; i <= n; i++)
    f[i] = (f[i - 1] * i) % mod;

  return ((f[n] * power(f[r], mod - 2)) % mod * power(f[n - r], mod - 2)) % mod;
}

int32_t main() {
  int n;
  cin >> n;
  int ans = 0;
  for (int c = 1; c < n; c++) {
    int ab = n - c;
    for (int i = 1; i * i <= ab; i++) {
      if (ab % i == 0) {
        if (ab / i == i)
          ans++;
        else
          ans += 2;
      }
    }
  }
  cout << ans;
}

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

int power(int x, int n) {
  if (x == 0)
    return 0;
  if (n == 0)
    return 1;
  if (n == 1)
    return x;
  int res = power(x, n / 2);
  res = (res * res) % mod;
  if (n % 2)
    return (res * x) % mod;
  return res;
}

int nCr(int n, int r) {
  if (r == 0)
    return 1;
  vector<int> f(n + 1);
  f[0] = 1;
  for (int i = 1; i <= n; i++)
    f[i] = (f[i - 1] * i) % mod;

  return ((f[n] * power(f[r], mod - 2)) % mod * power(f[n - r], mod - 2)) % mod;
}

const int MAX = 1000001;

// array to store prime factors
int factor[MAX] = {0};

// function to generate all prime factors
// of numbers from 1 to 10^6
void generatePrimeFactors() {
  factor[1] = 1;

  // Initializes all the positions with their value.
  for (int i = 2; i < MAX; i++)
    factor[i] = i;

  // Initializes all multiples of 2 with 2
  for (int i = 4; i < MAX; i += 2)
    factor[i] = 2;

  for (int i = 3; i * i < MAX; i++) {
    // check if it has no prime factor.
    if (factor[i] == i) {
      // Initializes of j starting from i*i
      for (int j = i * i; j < MAX; j += i) {
        // if it has no prime factor before, then
        // stores the smallest prime divisor
        if (factor[j] == j)
          factor[j] = i;
      }
    }
  }
}

int no_of_fac(int n) {
  if (n == 1)
    return 1;

  int ans = 1;
  int dup = factor[n];
  int c = 1;
  int 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;
}

int32_t main() {
  int n;
  cin >> n;
  int ans = 0;
  generatePrimeFactors();
  for (int c = 1; c < n; c++) {
    int ab = n - c;
    ans += no_of_fac(ab);
  }
  cout << ans;
}


#include <iostream>
using namespace std;
int main() {
  int n, i, j, k, count = 0;
  cin >> n;
  for (i = 1; i < n; i++) {
    for (j = 1; j <= (n - i); j++) {
      k = (n - i) % j;
      if (k == 0) {
        count++;
      }
    }
  }
  cout << count;
}

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


#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define pi pair<int, int>
#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
#define sz(x) ((int)x.size())
#define ln(x) ((int)x.length())
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define endl '\\n'
#define dbg(x) cout << #x << ": " << x << endl
#define clr(x, v) memset(x, v, sizeof(x))
#define dblout(x) cout << setprecision(x) << fixed;
#define FASTIO                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
const int MAXN = 1e6 + 5;

void cp() {
  int n;
  cin >> n;
  int cnt = 0;
  for (int i = 1; i <= n; i++) {
    int temp = n - i;
    int me = 0;
    for (int j = 1; j <= sqrt(temp); j++)
      if (temp % j == 0)
        me += 1 + (j != (temp / j));
    cnt += me;
  }
  cout << cnt << endl;
}

int main() {
  FASTIO;
  int t;
  t = 1;
  // cin >> t;
  while (t--) {
    cp();
  }
  return 0;
}

#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define pi pair<int, int>
#define all(x) x.begin(), x.end()
#define allr(x) x.rbegin(), x.rend()
#define sz(x) ((int)x.size())
#define ln(x) ((int)x.length())
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
#define endl '\\n'
#define dbg(x) cout << #x << ": " << x << endl
#define clr(x, v) memset(x, v, sizeof(x))
#define dblout(x) cout << setprecision(x) << fixed;
#define FASTIO                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
const int MAXN = 1e6 + 5;

vector<int> prime;
int lp[MAXN];
void init() {
  lp[1] = 1;
  for (int i = 2; i < MAXN; i++) {
    if (!lp[i])
      lp[i] = i, prime.pb(i);
    for (int j = 0; j < sz(prime) && i * 1LL * prime[j] < 1LL * MAXN; j++) {
      lp[i * prime[j]] = prime[j];
      if (i % prime[j] == 0)
        break;
    }
  }
}
void cp() {
  int n;
  cin >> n;
  int cnt = 0;
  for (int i = 1; i <= n; i++) {
    int temp = n - i;
    int me = 1;
    map<int, int> freq;
    while (temp > 1)
      freq[lp[temp]]++, temp /= lp[temp];
    for (auto &x : freq)
      me *= (x.ss + 1);
    cnt += me;
  }
  cout << cnt - 1 << endl;
}

int main() {
  FASTIO;
  int t;
  t = 1;
  init();
  // cin >> t;
  while (t--) {
    cp();
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define UNIQUE(v)                                                              \\
  v.erase(unique(v.begin(), v.end()), v.end()) // sortしてから使う
#define INF 2147483647
#define LLINF 9223372036854775807LL

int main() {
  int n;
  cin >> n;
  ll ans = 0;
  for (int c = 1; c < n; c++) {
    for (int a = 1; a * a < n; a++) {
      if ((n - c) % a == 0) {
        if (a == (n - c) / a) {
          /*
          cout << "だぶりa：" << a <<  endl;
          cout << "だぶりb：" << (n-c)/a << endl;
          cout << "c：" << c << endl;
          */
          ans++;
        } else if ((n - c) / a > a) {
          /*
          cout << "シングルa：" << a <<  endl;
          cout << "シングルb：" << (n-c)/a << endl;
          cout << "c：" << c << endl;
          */
          ans += 2;
        }
      }
    }
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define rep(i, n) for (int i = 0; i < n; i++)
#define UNIQUE(v)                                                              \\
  v.erase(unique(v.begin(), v.end()), v.end()) // sortしてから使う
#define INF 2147483647
#define LLINF 9223372036854775807LL

int main() {
  int n;
  cin >> n;
  int k = sqrt(n) / 1;
  // cout << "k:" << k << endl;
  int ans = 0;
  for (int a = 1; a <= k; a++) {
    ans += ((n / a) - a);
  }
  int count = 0;
  for (int i = 1; i * i <= n; i++) { // 約数をひく
    if (n % i == 0) {
      if (i * i != n)
        count += 2;
      else
        count++;
    }
  }
  // cout << "count:" << count << endl;
  ans *= 2;
  ans += k;
  ans -= count;
  cout << ans << endl;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
             tree_order_statistics_node_update>
    oset;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x)                                                                 \\
  sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<(    \\
            c i) {
sim > struct rge {
  c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
  ~debug() { cerr << endl; }
  eni(!=) cerr << boolalpha << i;
  ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
  sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using ll = long long;
#define ar array

void test_case() {
  int count = 0;
  int N;
  cin >> N;
  for (int i = 1; i < N; i++) {
    for (int j = 1; j <= sqrt(N - i); j++) {
      if ((N - i) % j == 0) {
        if ((N - i) / j != j)
          count += 2;
        else
          count += 1;
      }
    }
  }
  cout << count;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int T = 1;
  // cin >> T;
  while (T--) {
    test_case();
  }
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
             tree_order_statistics_node_update>
    oset;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x)                                                                 \\
  sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<(    \\
            c i) {
sim > struct rge {
  c b, e;
};
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
  ~debug() { cerr << endl; }
  eni(!=) cerr << boolalpha << i;
  ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
  sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using ll = long long;
#define ar array
const int m = 1e9 + 7;
int countDivisors(int n) {
  int cnt = 0;
  for (int i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      // If divisors are equal,
      // count only one
      if (n / i == i)
        cnt++;

      else // Otherwise count both
        cnt = cnt + 2;
    }
  }
  return cnt;
}

void test_case() {
  int count = 0;
  int N;
  cin >> N;
  for (int i = 1; i < N; i++)
    count += countDivisors(i);
  cout << count;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int T = 1;
  // cin >> T;
  while (T--) {
    test_case();
  }
}


#include <cmath>
#include <iostream>
using namespace std;
int main(void) {
  int n;
  cin >> n;
  int count = 0, i, j;
  for (i = 1; i < n; i++) {
    double sq = sqrt(n - i);
    for (j = 1; j <= sq; j++) {
      if ((n - i) % j == 0) {
        if (sq == (double)j) {
          count++;
        } else {
          count += 2;
        }
      }
    }
  }
  cout << count << endl;
  return 0;
}

#include <cmath>
#include <iostream>
using namespace std;
int main(void) {
  int n;
  cin >> n;
  int count = 0, i, j;
  for (i = 1; i < n; i++) {
    int tmp = n - i;
    double sq = sqrt(tmp);
    for (j = 1; j <= sq; j++) {
      if (tmp % j == 0) {
        if (sq == (double)j) {
          count++;
        } else {
          count += 2;
        }
      }
    }
  }
  cout << count << endl;
  return 0;
}


#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i < (int)(n); i++)

using namespace std;
typedef long long ll;

int main() {
  ll N;
  ll a, b, c;
  ll count, ans;
  cin >> N;
  count = 0;
  rep(a, 1000) {
    rep(b, 1000) {
      rep(c, N) {
        ans = a * b + c;
        if (ans == N)
          count++;
      }
    }
  }
  cout << count;

  return 0;
}

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i < (int)(n); i++)

using namespace std;
typedef long long ll;

int main() {
  ll N;
  ll a, b;
  ll count, ans;

  cin >> N;
  count = 0;

  rep(a, N) {
    rep(b, N) {
      ans = a * b;
      if (a * b < N)
        count++;
      else
        break;
    }
  }
  cout << count;
  return 0;
}


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

/*2進数配列+1*/
vector<int> twoadd(vector<int> v, int N) {
  v[N - 1] += 1;
  int ind = N - 1;
  int j = N - 1;
  for (j = N - 1; j >= 1; j--) {
    if (v[j] > 1) {
      v[j - 1] += 1;
      v[j] = 0;
    }
  }
  return v;
}

/*フィボナッチ*/
long long fibonatti(long long d) {
  long long count = 0;
  long long f1 = 1;
  long long f2 = 1; /*ここを変える*/
  long long temp;
  if (d == 1) {
    count = f1;
  } else if (d == 2) {
    count = f2;
  } else if (d == 0) {
    count = 1;
  } else {
    for (int i = 0; i < d - 2; i++) {
      temp = f1 + f2;
      f1 = f2;
      f2 = temp;
    }
    count = temp;
  }
  return count;
}

/*最大公約数*/
unsigned long long GCD(long long L, long long R) {
  if (L > R) {
    long long temp = R;
    R = L;
    L = temp;
  }
  unsigned long long pp = 0, ppt = 0;
  unsigned long long ans = 0;
  if (R % L == 0) {
    ans = L;
  } else {
    while (true) {
      ppt = pp;
      pp = R % L;
      if (pp == 0) {
        ans = ppt;
        break;
      }
      R = L;
      L = pp;
    }
  }
  return ans;
}

/*最小公倍数*/
unsigned long long LCM(long long L, long long R) {
  unsigned long long ans;
  unsigned long long gcd = GCD(L, R);
  ans = (L / gcd) * R;
  return ans;
}

/*Combination set*/
#define mod 1000000007
#define maxcomb 1000000 /*大きいものを求めるときはここを変える*/
vector<long long> fc(maxcomb + 1);
vector<long long> ifc(maxcomb + 1);
/*modpowは(10,N)>(9,N)とは限らず、(10,N)-(9,N)をするときは必ずans =
 * (ans+mod)%mod;をして正の値に*/
long long modpow(long long x, long long n) {
  long long ans = 1;
  while (n > 0) {
    if (n & 1) {
      ans = ans * x % mod;
    }
    x = x * x % mod;
    n >>= 1;
  }
  return ans;
}
void Conb() {
  fc[0] = 1;
  ifc[0] = 1;
  for (long long i = 0; i < maxcomb; i++) {
    fc[i + 1] = fc[i] * (i + 1) % mod;                  // n!(mod)
    ifc[i + 1] = ifc[i] * modpow(i + 1, mod - 2) % mod; // k!^{M-2} (mod)
  }
}
unsigned long long Combination(long long L, long long R) {
  unsigned long long up = 1, ans;
  Conb();
  if (L == 0 && R == 0) {
    return 1;
  } else if (L < R || L < 0) {
    return 0;
  } else {
    long long t = ifc[L - R] * ifc[R] % mod;
    ans = t * fc[L] % mod;
  }
  return ans;
}
/*Combination set ここまで*/

/*ここから*/
long countYak(long long K) {
  long N = sqrt(K);
  bool b = false;
  if (sqrt(K) - N == 0) {
    b = true;
  }
  long count = 1;
  if (K == 1) {
    return 1;
  }
  if (K == 2) {
    return 2;
  }
  if (K == 3) {
    return 2;
  }
  if (K == 4) {
    return 3;
  }
  if (K == 6) {
    return 4;
  }
  if (K % 2 != 0) {
    if (K % 3 != 0) {
      for (int i = 4; i < N; i += 2) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    } else {
      count += 1;
      for (int i = 4; i < N; i += 2) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    }
  } else {
    count += 1;
    if (K % 3 != 0) {
      for (int i = 3; i < N; i++) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    } else {
      count += 1;
      for (int i = 3; i < N; i++) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    }
  }
  if (b == false) {
    count *= 2;
  } else {
    count = (count - 1) * 2 + 1;
  }
  return count;
}

int main() {
  ll N;
  cin >> N;
  ll A = 1, B = 1, C = 1, count = 0;
  for (int i = 0; i < N - 1; i++) {
    count += countYak(i + 1);
  }
  cout << count << endl;
  return 0;
}

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

/*2進数配列+1*/
vector<int> twoadd(vector<int> v, int N) {
  v[N - 1] += 1;
  int ind = N - 1;
  int j = N - 1;
  for (j = N - 1; j >= 1; j--) {
    if (v[j] > 1) {
      v[j - 1] += 1;
      v[j] = 0;
    }
  }
  return v;
}

/*フィボナッチ*/
long long fibonatti(long long d) {
  long long count = 0;
  long long f1 = 1;
  long long f2 = 1; /*ここを変える*/
  long long temp;
  if (d == 1) {
    count = f1;
  } else if (d == 2) {
    count = f2;
  } else if (d == 0) {
    count = 1;
  } else {
    for (int i = 0; i < d - 2; i++) {
      temp = f1 + f2;
      f1 = f2;
      f2 = temp;
    }
    count = temp;
  }
  return count;
}

/*最大公約数*/
unsigned long long GCD(long long L, long long R) {
  if (L > R) {
    long long temp = R;
    R = L;
    L = temp;
  }
  unsigned long long pp = 0, ppt = 0;
  unsigned long long ans = 0;
  if (R % L == 0) {
    ans = L;
  } else {
    while (true) {
      ppt = pp;
      pp = R % L;
      if (pp == 0) {
        ans = ppt;
        break;
      }
      R = L;
      L = pp;
    }
  }
  return ans;
}

/*最小公倍数*/
unsigned long long LCM(long long L, long long R) {
  unsigned long long ans;
  unsigned long long gcd = GCD(L, R);
  ans = (L / gcd) * R;
  return ans;
}

/*Combination set*/
#define mod 1000000007
#define maxcomb 1000000 /*大きいものを求めるときはここを変える*/
vector<long long> fc(maxcomb + 1);
vector<long long> ifc(maxcomb + 1);
/*modpowは(10,N)>(9,N)とは限らず、(10,N)-(9,N)をするときは必ずans =
 * (ans+mod)%mod;をして正の値に*/
long long modpow(long long x, long long n) {
  long long ans = 1;
  while (n > 0) {
    if (n & 1) {
      ans = ans * x % mod;
    }
    x = x * x % mod;
    n >>= 1;
  }
  return ans;
}
void Conb() {
  fc[0] = 1;
  ifc[0] = 1;
  for (long long i = 0; i < maxcomb; i++) {
    fc[i + 1] = fc[i] * (i + 1) % mod;                  // n!(mod)
    ifc[i + 1] = ifc[i] * modpow(i + 1, mod - 2) % mod; // k!^{M-2} (mod)
  }
}
unsigned long long Combination(long long L, long long R) {
  unsigned long long up = 1, ans;
  Conb();
  if (L == 0 && R == 0) {
    return 1;
  } else if (L < R || L < 0) {
    return 0;
  } else {
    long long t = ifc[L - R] * ifc[R] % mod;
    ans = t * fc[L] % mod;
  }
  return ans;
}
/*Combination set ここまで*/

/*ここから*/
long countYak(long long K) {
  long N = sqrt(K);
  bool b = false;
  if (sqrt(K) - N == 0) {
    b = true;
  }
  long count = 1;
  if (K == 1) {
    return 1;
  }
  if (K == 2) {
    return 2;
  }
  if (K == 3) {
    return 2;
  }
  if (K == 4) {
    return 3;
  }
  if (K == 6) {
    return 4;
  }
  if (K % 2 != 0) {
    if (K % 3 != 0) {
      for (int i = 4; i < N; i += 2) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    } else {
      count += 1;
      for (int i = 4; i < N; i += 2) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    }
  } else {
    count += 1;
    if (K % 3 != 0) {
      for (int i = 3; i < N; i++) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    } else {
      count += 1;
      for (int i = 3; i < N; i++) {
        if (K % (i + 1) == 0) {
          count++;
        }
      }
    }
  }
  if (b == false) {
    count *= 2;
  } else {
    count = (count - 1) * 2 + 1;
  }
  return count;
}

int main() {
  ll N;
  cin >> N;
  ll A = 1, B = 1, C = 1, count = 0;
  for (int i = 1; i < N; i++) {
    count += (N - 1) / i;
  }
  cout << count << endl;
  return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define mp make_pair
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define MOD 1000000007
#define endl "\\n"
typedef long long ll;
using namespace std;

int main() {
  // freopen("input.txt","r",stdin);
  // freopen("output.txt","w",stdout);
  ll n;
  cin >> n;
  ll r = n;
  ll prod, limit, count;
  count = 0;

  for (auto i = 1; i <= n; i++) {

    prod = r - i;

    limit = sqrt(prod);
    // cerr<<limit<<" ";
    for (auto j = 1; j <= limit; j++) {
      // cerr<<"prod= "<<prod<<", "<<"j= "<<j<<endl;
      if (prod % j == 0) {
        count += 2;
        // cout<<"hi";
      }
      if (prod % j == 0 && prod / j == j)
        count--;
    }
  }

  cout << count << endl;

  return 0;
}

#include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define mp make_pair
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define MOD 1000000007
#define endl "\\n"
typedef long long ll;
using namespace std;

int main() {
  // freopen("input.txt","r",stdin);
  // freopen("output.txt","w",stdout);
  ll n;
  cin >> n;
  ll ans = 0;
  for (int i = 1; i <= n; i++) {
    ans = ans + (n - 1) / i;
  }

  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
// long long int i,j,k,n,m,a,b,c,d,p,q,r,l,t=1;
// long long int sum,counted,ans;
void fast() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
}
void sample() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
}
long long int *read(long long int n) {
  long long int *arr = new long long int[n];

  for (int i = 0; i < n; i++)
    cin >> arr[i];

  return arr;
}
long long int countDivisors(long long int n) {
  long long int cnt = 0;
  for (long long int i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      // If divisors are equal,
      // count only one
      if (n / i == i)
        cnt++;

      else // Otherwise count both
        cnt = cnt + 2;
    }
  }
  return cnt;
}

int divCount(int n) {
  // sieve method for prime calculation
  bool hash[n + 1];
  memset(hash, true, sizeof(hash));
  for (int p = 2; p * p < n; p++)
    if (hash[p] == true)
      for (int i = p * 2; i < n; i += p)
        hash[i] = false;

  // Traversing through all prime numbers
  int total = 1;
  for (int p = 2; p <= n; p++) {
    if (hash[p]) {

      // calculate number of divisor
      // with formula total div =
      // (p1+1) * (p2+1) *.....* (pn+1)
      // where n = (a1^p1)*(a2^p2)....
      // *(an^pn) ai being prime divisor
      // for n and pi are their respective
      // power in factorization
      int count = 0;
      if (n % p == 0) {
        while (n % p == 0) {
          n = n / p;
          count++;
        }
        total = total * (count + 1);
      }
    }
  }
  return total;
}

void solve() {
  long long int n, i, j, k, ans, m, o;

  cin >> n;

  // long long int ar[n];

  // long long int* ar=read(n);

  ans = 0;

  for (i = 1; i < n; i++) {
    ans += countDivisors(i);
  }

  cout << ans;

  return;
}

int main() {
  fast();
  sample();
  long long int i, j, k, n, m, a, b, c, d, p, q, r, l, t = 1;
  long long int sum, count = 0, ans = 0;

  // cin >> t;
  while (t--) {
    solve();
  }

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
// long long int i,j,k,n,m,a,b,c,d,p,q,r,l,t=1;
// long long int sum,counted,ans;
void fast() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
}
void sample() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
}
long long int *read(long long int n) {
  long long int *arr = new long long int[n];

  for (int i = 0; i < n; i++)
    cin >> arr[i];

  return arr;
}
long long int countDivisors(long long int n) {
  long long int cnt = 0;
  for (long long int i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      // If divisors are equal,
      // count only one
      if (n / i == i)
        cnt++;

      else // Otherwise count both
        cnt = cnt + 2;
    }
  }
  return cnt;
}

void solve() {
  long long int n, i, j, k, ans, m, o;

  cin >> n;

  // long long int ar[n];

  // long long int* ar=read(n);

  ans = 0;

  for (i = 1; i < n; i++) {
    ans += (n / i);
    if (n % i == 0)
      ans--;
  }

  cout << ans;

  return;
}

int main() {
  fast();
  sample();
  long long int i, j, k, n, m, a, b, c, d, p, q, r, l, t = 1;
  long long int sum, count = 0, ans = 0;

  // cin >> t;
  while (t--) {
    solve();
  }

  return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>
#define ll long long
#define pb push_back
#define ppb pop_back
#define si set<ll>
#define endl '\\n'
#define fr first
#define sc second
#define mii map<ll, ll>
#define msi map<string, ll>
#define mis map<ll, string>
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pair<ll, ll>>
#define vs vector<string>
#define sz(x) (ll) x.size()
#define rt return
#define spl " "
#define M 1000000007
#define bs binary_search
#define rev(a) reverse(all(a));
#define sp(n) setprecision(n)
#define spl " "
#define arr(a, n) rep(i, 0, n) cin >> a[i]
#define mod 998244353
#define time                                                                   \\
  cout << "\\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\\n";
#define INF 1ll << 31
#define rt return
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\\'' << x << '\\''; }
void __print(const char *x) { cerr << '\\"' << x << '\\"'; }
void __print(const string &x) { cerr << '\\"' << x << '\\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
  cerr << '{';
  __print(x.first);
  cerr << ',';
  __print(x.second);
  cerr << '}';
}
template <typename T> void __print(const T &x) {
  int f = 0;
  cerr << '{';
  for (auto &i : x)
    cerr << (f++ ? "," : ""), __print(i);
  cerr << "}";
}
void _print() { cerr << "]\\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
  __print(t);
  if (sizeof...(v))
    cerr << ", ";
  _print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...)                                                            \\
  cerr << "[" << #x << "] = [";                                                \\
  _print(x)
#else
#define debug(x...)
#endif
ll bpow(ll a, ll b, ll mm = M) {
  ll res = 1;

  while (b) {
    if (b & 1)
      res = (res * a) % mm;
    a = (a * a) % mm;

    b >>= 1;
  }

  return res;
}
ll modInverse(ll A, ll mm) { return bpow(A, mm - 2, mm); }

ll nCrModPFermat(ll n, ll r, ll p) {
  if (r == 0)
    return 1;
  ll fac[n + 1];
  fac[0] = 1;
  fac[1] = 1;
  for (ll i = 2; i <= n; i++)
    fac[i] = fac[i - 1] * i % M;
  return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
         p;
}

void solve() {
  ll n;
  cin >> n;
  ll ans = 0;
  for (ll c = 1; c <= n; c++) {

    ll temp = n - c;
    if (temp > 0) {
      ll res = 0;
      for (ll i = 1; i <= sqrt(temp); i++) {
        if (temp % i == 0) {
          if (i != temp / i)
            res += 2;
          else
            res++;
        }
      }
      if (res % 2 == 1) {
        ans += (res / 2) * 2 + 1;
      } else
        ans += res;
    }
  }
  cout << ans << endl;
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  ll t = 1;
  // cin>>t;
  while (t--)
    solve();
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>
#define ll long long
#define pb push_back
#define ppb pop_back
#define si set<ll>
#define endl '\\n'
#define fr first
#define sc second
#define mii map<ll, ll>
#define msi map<string, ll>
#define mis map<ll, string>
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define pii pair<ll, ll>
#define vi vector<ll>
#define vii vector<pair<ll, ll>>
#define vs vector<string>
#define sz(x) (ll) x.size()
#define rt return
#define spl " "
#define M 1000000007
#define bs binary_search
#define rev(a) reverse(all(a));
#define sp(n) setprecision(n)
#define spl " "
#define arr(a, n) rep(i, 0, n) cin >> a[i]
#define mod 998244353
#define time                                                                   \\
  cout << "\\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\\n";
#define INF 1ll << 31
#define rt return
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\\'' << x << '\\''; }
void __print(const char *x) { cerr << '\\"' << x << '\\"'; }
void __print(const string &x) { cerr << '\\"' << x << '\\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V> void __print(const pair<T, V> &x) {
  cerr << '{';
  __print(x.first);
  cerr << ',';
  __print(x.second);
  cerr << '}';
}
template <typename T> void __print(const T &x) {
  int f = 0;
  cerr << '{';
  for (auto &i : x)
    cerr << (f++ ? "," : ""), __print(i);
  cerr << "}";
}
void _print() { cerr << "]\\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
  __print(t);
  if (sizeof...(v))
    cerr << ", ";
  _print(v...);
}
#ifndef ONLINE_JUDGE
#define debug(x...)                                                            \\
  cerr << "[" << #x << "] = [";                                                \\
  _print(x)
#else
#define debug(x...)
#endif
ll bpow(ll a, ll b, ll mm = M) {
  ll res = 1;

  while (b) {
    if (b & 1)
      res = (res * a) % mm;
    a = (a * a) % mm;

    b >>= 1;
  }

  return res;
}
ll modInverse(ll A, ll mm) { return bpow(A, mm - 2, mm); }

ll nCrModPFermat(ll n, ll r, ll p) {
  if (r == 0)
    return 1;
  ll fac[n + 1];
  fac[0] = 1;
  fac[1] = 1;
  for (ll i = 2; i <= n; i++)
    fac[i] = fac[i - 1] * i % M;
  return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
         p;
}

ll dp[1000005];
void solve() {
  ll n;
  cin >> n;
  memset(dp, 0, sizeof(dp));
  for (ll i = 1; i <= n; i++)
    for (ll j = 1; j * i <= n; j++)
      dp[i * j]++;
  // for(ll i=1;i<=n;i++) cout<<dp[i]<<" ";cout<<endl;
  ll ans = 0;
  for (ll c = 1; c < n; c++) {
    ll temp = n - c;
    if (temp > 0) {
      ll cnt = dp[temp];
      if (cnt % 2 == 0)
        ans += cnt;
      else
        ans += (cnt / 2) * 2 + 1;
    }
  }
  cout << ans << endl;
}

signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  ll t = 1;
  // cin>>t;
  while (t--)
    solve();
}


#include <bits/stdc++.h>
#define ll long long
#define pb push_back
ll mod = 1000000007;
using namespace std;

int main() {
  ll n;
  cin >> n;
  ll c = 0;
  for (ll i = 1; i < n; i++) {
    for (ll j = 1; j < n; j++) {
      if (i * j < n) {
        c++;
      }
    }
  }

  cout << c << endl;
}

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
ll mod = 1000000007;
using namespace std;

int main() {
  ll n;
  cin >> n;
  ll c = 0;
  for (ll i = 1; i < n; i++) {
    for (ll j = 1; j < n; j++) {
      if (i * j < n) {
        c++;
      } else {
        break;
      }
    }
  }

  cout << c << endl;
}


////=====BIsmillahir Rahmanir Rahim =====////

/*                        ______
 _______   /\\     |``\\   |        |  /
    |     /  \\    |__/   |____    |/
    |    / _ _\\   |  \\   |        |\\
    |   /      \\  |   \\  |______  |  \\

            Dept. of CSE
         Comilla University

*/
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
#define fi 2 * acos(0.0)
#define ee 2.71828
#define ll long long
#define FIO                                                                    \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define ff first
#define ss second
#define valid(nx, ny) nx >= 0 && nx < n &&ny >= 0 && ny < m
#define edl printf("\\n")
#define infinity 1e16
#define mod 1000000007
#define cn continue
#define csprint1 printf("Case %lld: ", cs++)
#define csprint2 printf("Case %lld:\\n", cs++)
#define sf(a) scanf("%lld", &a)
#define sff(a, b) scanf("%lld %lld", &a, &b)
#define sfff(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffff(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define all(v) v.begin(), v.end()
#define pfn(a) printf("%lld\\n", a)
#define pfs(a) printf("%lld ", a)

// using namespace __gnu_pbds;
using namespace std;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<pl> vpi;
typedef vector<pl> vpl;
// typedef tree<pair<ll, int> , null_type, less<pair<ll, int> >, rb_tree_tag,
// tree_order_statistics_node_update> ost;
#define error(args...)                                                         \\
  {                                                                            \\
    string _s = #args;                                                         \\
    replace(_s.begin(), _s.end(), ',', ' ');                                   \\
    stringstream _ss(_s);                                                      \\
    istream_iterator<string> _it(_ss);                                         \\
    err(_it, args);                                                            \\
  }
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << "," << spc;
  err(++it, args...);
  cout << edl;
}
/// Bit manipulation

bool checkbit(int mask, int bit) { return mask & (1 << bit); }
int setbit(int mask, int bit) { return mask | (1 << bit); }
int clearbit(int mask, int bit) { return mask & ~(1 << bit); }
int togglebit(int mask, int bit) { return mask ^ (1 << bit); }
int bitno(int mask) { return (int)__builtin_popcount(mask); }

/*----------------------Graph Moves----------------*/
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
// const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
// const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

///=====================================///
const long long maX = 1e6 + 5;
bool prime[maX];
void isprime() {
  prime[0] = prime[1] = true;
  for (ll i = 4; i <= maX; i += 2)
    prime[i] = true;
  for (ll i = 3; i * i <= maX; i += 2) {
    if (prime[i] == 0) {
      for (ll j = i * i; j <= maX; j += (i + i))
        prime[j] = true;
    }
  }
  // for(ll i=1;i<=100;i++)cout<<i<<spc<<prime[i]<<endl;
}
int main() {
  isprime();
  ll n;
  sf(n);
  ll cc = 0;
  for (ll i = 1; i < n; i++) {
    cc += 2;
    if (prime[i]) {
      for (ll j = 2; j * j <= i; j++) {
        if (i % j == 0) {
          if (i / j == j)
            cc++;
          else
            cc += 2;
        }
      }
    }
  }
  pfn(cc - 1);
  return 0;
}

////=====BIsmillahir Rahmanir Rahim =====////

/*                        ______
 _______   /\\     |``\\   |        |  /
    |     /  \\    |__/   |____    |/
    |    / _ _\\   |  \\   |        |\\
    |   /      \\  |   \\  |______  |  \\

            Dept. of CSE
         Comilla University

*/
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/detail/standard_policies.hpp>
#define fi 2 * acos(0.0)
#define ee 2.71828
#define ll long long
#define FIO                                                                    \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define ff first
#define ss second
#define valid(nx, ny) nx >= 0 && nx < n &&ny >= 0 && ny < m
#define edl printf("\\n")
#define infinity 1e16
#define mod 1000000007
#define cn continue
#define csprint1 printf("Case %lld: ", cs++)
#define csprint2 printf("Case %lld:\\n", cs++)
#define sf(a) scanf("%lld", &a)
#define sff(a, b) scanf("%lld %lld", &a, &b)
#define sfff(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define sffff(a, b, c, d) scanf("%lld %lld %lld %lld", &a, &b, &c, &d)
#define all(v) v.begin(), v.end()
#define pfn(a) printf("%lld\\n", a)
#define pfs(a) printf("%lld ", a)

// using namespace __gnu_pbds;
using namespace std;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<pl> vpi;
typedef vector<pl> vpl;
// typedef tree<pair<ll, int> , null_type, less<pair<ll, int> >, rb_tree_tag,
// tree_order_statistics_node_update> ost;
#define error(args...)                                                         \\
  {                                                                            \\
    string _s = #args;                                                         \\
    replace(_s.begin(), _s.end(), ',', ' ');                                   \\
    stringstream _ss(_s);                                                      \\
    istream_iterator<string> _it(_ss);                                         \\
    err(_it, args);                                                            \\
  }
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << "," << spc;
  err(++it, args...);
  cout << edl;
}
/// Bit manipulation

bool checkbit(int mask, int bit) { return mask & (1 << bit); }
int setbit(int mask, int bit) { return mask | (1 << bit); }
int clearbit(int mask, int bit) { return mask & ~(1 << bit); }
int togglebit(int mask, int bit) { return mask ^ (1 << bit); }
int bitno(int mask) { return (int)__builtin_popcount(mask); }

/*----------------------Graph Moves----------------*/
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
// const int fx[]={+0,+0,+1,-1,-1,+1,-1,+1};   // Kings Move
// const int fy[]={-1,+1,+0,+0,+1,+1,-1,-1};  // Kings Move
// const int fx[]={-2, -2, -1, -1,  1,  1,  2,  2};  // Knights Move
// const int fy[]={-1,  1, -2,  2, -2,  2, -1,  1}; // Knights Move
/*------------------------------------------------*/

///=====================================///
const long long maX = 1e6 + 5;
ll divisor[maX];
int main() {
  ll n;
  sf(n);
  ll cc = 0;
  for (ll i = 1; i < n; i++) {
    for (ll j = i; i * j < n; j++) {
      if (i != j)
        divisor[i * j]++;
      divisor[i * j]++;
    }
  }
  for (ll i = 1; i < n; i += 1) {
    cc += divisor[i];
  }
  pfn(cc);
  return 0;
}


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

#include <bits/stdc++.h>
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;
}