#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repI(i, d, n) for (int i = (d); i < (n); ++i)
#define reps1(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using M = map<int, int>;
using Ml = map<ll, ll>;
ll const INF = 1ll << 61;
double pi = 3.141592653589793238;

int main() {
  ll n;
  cin >> n;
  ll cnt = 0;
  reps1(i, n) {
    for (ll j = 1; j * j <= n - i; j++) {
      if ((n - i) % j == 0) {
        if ((n - i) / j == j)
          cnt++;
        else
          cnt += 2;
      }
      // cout << n-i << " " << j << " " << cnt << endl;
    }
  }

  cout << cnt << endl;

  return 0;
}

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repI(i, d, n) for (int i = (d); i < (n); ++i)
#define reps1(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using M = map<int, int>;
using Ml = map<ll, ll>;
ll const INF = 1ll << 61;
double pi = 3.141592653589793238;
ll const MAXVAL = 1e6;

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

  vector<ll> table(n + 1);
  for (ll i = 1; i * i <= n; i++) {
    for (ll j = i; i * j <= n; j++) {
      if (i == j)
        table[i * j]++;
      else
        table[i * j] += 2;
    }
  }

  ll ans = 0;
  reps1(i, n) ans += table[i];
  cout << ans << endl;

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  long int n;
  cin >> n;
  long long int ans = 0;
  for (int i = 1; i < n; i++) {
    for (int j = 1; j * j <= n - i; j++) {
      if ((n - i) % j == 0) {
        if ((n - i) / j != j)
          ans += 2;
        else
          ans++;
      }
    }
  }
  cout << ans;
}

#include <iostream>

using namespace std;

int main() {
  long int n;
  cin >> n;
  long long int dp[n + 1] = {0};
  dp[0] = 0;
  dp[1] = 0;
  for (long int i = 2; i <= n; i++) {
    dp[i] = dp[i - 1];
    long long int noOfFactors = 1;
    long long int no = i - 1;
    for (long long int j = 2; j * j <= no; j++) {
      if (no % j == 0) {
        long long int p = 0;
        while (no % j == 0) {
          no /= j;
          p++;
        }
        noOfFactors *= (p + 1);
      }
    }
    if (no != 1) {
      noOfFactors *= 2;
    }
    dp[i] += noOfFactors;
  }
  cout << dp[n];
}


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

int main() {
  ll n, a = 0;
  cin >> n;
  ll k = n - 1;
  for (ll i = 1; i < n; i++) {
    ll p = n - i;
    ll j = 1;
    while (p >= j) {
      if (p % j == 0)
        a++;
      j++;
    }
  }
  cout << a << endl;
}

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

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


#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const ll MOD = (ll)1e9 + 7;
const double PI = 3.14159265358979323846;
template <class T, class U> void chmin(T &t, const U &u) {
  if (t > u)
    t = u;
}
template <class T, class U> void chmax(T &t, const U &u) {
  if (t < u)
    t = u;
}

int main(void) {
  int n;
  cin >> n;
  ll cnt = 0;
  for (int c = 1; c < n; ++c) {
    for (int a = 1; a * a <= n - c; ++a) {
      if ((n - c) % a == 0)
        cnt += 2;
      if ((n - c) == a * a)
        cnt--;
    }
  }
  cout << cnt << endl;
  return 0;
}

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const ll MOD = (ll)1e9 + 7;
const double PI = 3.14159265358979323846;
template <class T, class U> void chmin(T &t, const U &u) {
  if (t > u)
    t = u;
}
template <class T, class U> void chmax(T &t, const U &u) {
  if (t < u)
    t = u;
}

int main(void) {
  int n;
  cin >> n;
  ll cnt = 0;
  int a;
  for (int c = 1; c < n; ++c) {
    for (a = 1; a * a < n - c; ++a) {
      if ((n - c) % a == 0)
        cnt += 2;
      // if ((n - c) == a * a) cnt--;
    }
    if ((n - c) == a * a)
      cnt++;
  }
  cout << cnt << endl;
  return 0;
}


#include <bits/stdc++.h>

using namespace std;

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

  for (int a = 1; a <= n; a++) {
    for (int b = 1; b <= n; b++) {
      ans += n - a * b > 0;
    }
  }

  cout << ans << endl;
}

#include <bits/stdc++.h>

using namespace std;

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

  for (int a = 1; a <= n; a++) {
    for (int b = 1; b <= n; b++) {
      if (a * b < n)
        ans++;
      else
        break;
    }
  }

  cout << ans << endl;
}


/*
 *author: rits1272
 */
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define F first
#define S second
#define MAX 1e9
#define MIN -1e9
#define INF 1e18
#define MOD 1000000007
#define int long long
#define FOR(x, n) for (int i = x; i < n; i++)
#define print(x) cout << "[" << #x << ":" << x << "] ";
#define println(x) cout << "[" << #x << ":" << x << "]\\n";

int dx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int dy[8] = {0, 1, -1, 0, -1, 1, -1, 1};
double PI = acos(-1);

int divisors(int x) {
  int res = 0;
  for (int i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      if (x / i == i)
        res++;
      else
        res += 2;
    }
  }
  return res;
}

int32_t main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
#ifndef ONLINE_JUDGE
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i <= n; i++) {
    int res = n - i;
    ans += divisors(res);
  }
  cout << ans << '\\n';
  return 0;
}

/*
 *author: rits1272
 */
#include <bits/stdc++.h>
using namespace std;

#define pb push_back
#define F first
#define S second
#define MAX 1e9
#define MIN -1e9
#define INF 1e18
#define MOD 1000000007
#define int long long
#define FOR(x, n) for (int i = x; i < n; i++)
#define print(x) cout << "[" << #x << ":" << x << "] ";
#define println(x) cout << "[" << #x << ":" << x << "]\\n";

int dx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};
int dy[8] = {0, 1, -1, 0, -1, 1, -1, 1};
double PI = acos(-1);

const int mxN = 1000000;
int n;

int32_t main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
#ifndef ONLINE_JUDGE
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; i++) {
    ans += (n - 1) / i;
  }
  cout << ans << '\\n';
  return 0;
}


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

int main() {
  int N;
  cin >> N;
  int p = 0;
  int q = 0;

  for (int a = 1; a < sqrt(N); a++) {
    int b;
    for (int c = 1; c < N; c++) {
      b = (N - c) / a;
      if ((N - c) % a == 0 && a < b) {
        p++;
      }
      if ((N - c) % a == 0 && a == b) {
        q++;
      }
    }
  }

  cout << 2 * p + q << endl;
}

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

int main() {
  int N;
  cin >> N;
  int p = 0;
  int q = 0;
  int b;

  for (int a = 1; a < sqrt(N); a++) {
    for (int c = 1; c <= (N - a * a); c++) {
      b = (N - c) / a;
      if ((N - c) % a == 0 && a < b) {
        p++;
      } else if ((N - c) % a == 0 && a == b) {
        q++;
      }
    }
  }

  cout << 2 * p + q << endl;
}


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

int main() {
  long N;
  cin >> N;
  vector<int> cha(N - 1, 0);
  int count = 0;

  rep(i, N - 1) { cha[i] = N - (i + 1); }

  rep(i, N - 1) {
    rep(j, N - 1) {
      if (cha[i] % (j + 1) == 0) {
        count++;
      }
    }
  }

  cout << count << endl;
}

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

int main() {
  long N;
  cin >> N;
  int ans = 0;

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

  cout << ans << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using P = pair<int, int>;
int yakusu(int s) {
  int cnt = 0;
  int w = 1;
  while (w <= s) {
    if (s % w == 0)
      cnt++;
    w++;
  }
  return cnt;
}
int main() {
  int n;
  cin >> n;
  ll ans = 0;
  for (int i = 1; i <= n - 1; i++) {
    int j = n - i;
    // iを因数分解
    ans += yakusu(i);
  }
  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using P = pair<int, int>;
int yakusu(int s) {
  int cnt = 0;
  int w = 1;
  while (w <= sqrt(s)) {
    if (s % w == 0) {
      cnt++;
      if (w * w != s)
        cnt++;
    }
    w++;
  }
  return cnt;
}
int main() {
  int n;
  cin >> n;
  ll ans = 0;
  for (int i = 1; i <= n - 1; i++) {
    int j = n - i;
    // iを因数分解
    ans += yakusu(i);
  }
  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;

const int MOD = 1e9 + 7;
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpll vector<pll>
#define vpii vector<pii>
#define umap unordered_map
#define uset unordered_set
#define PQ priority_queue

inline void normal(ll &a) {
  a %= MOD;
  (a < 0) && (a += MOD);
}
inline ll modMul(ll a, ll b) {
  a %= MOD, b %= MOD;
  normal(a), normal(b);
  return (a * b) % MOD;
}
inline ll modAdd(ll a, ll b) {
  a %= MOD, b %= MOD;
  normal(a), normal(b);
  return (a + b) % MOD;
}
inline ll modSub(ll a, ll b) {
  a %= MOD, b %= MOD;
  normal(a), normal(b);
  a -= b;
  normal(a);
  return a;
}
inline ll modPow(ll b, ll p) {
  ll r = 1;
  while (p) {
    if (p & 1)
      r = modMul(r, b);
    b = modMul(b, b);
    p >>= 1;
  }
  return r;
}
inline ll modInverse(ll a) { return modPow(a, MOD - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }

/// geometry TEMPLATE

const double eps = 1e-9;
const double PI = acos(-1.0);
int sign(double x) { return (x > eps) - (x < -eps); }
struct PT {
  double x, y;
  PT() { x = 0, y = 0; }
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &a) const { return PT(x + a.x, y + a.y); }
  PT operator-(const PT &a) const { return PT(x - a.x, y - a.y); }
  PT operator*(const double a) const { return PT(x * a, y * a); }
  friend PT operator*(const double &a, const PT &b) {
    return PT(a * b.x, a * b.y);
  }
  PT operator/(const double a) const { return PT(x / a, y / a); }
  bool operator==(PT a) const {
    return sign(a.x - x) == 0 && sign(a.y - y) == 0;
  }
  bool operator!=(PT a) const { return !(*this == a); }
  bool operator<(PT a) const { return sign(a.x - x) == 0 ? y < a.y : x < a.x; }
  bool operator>(PT a) const { return sign(a.x - x) == 0 ? y > a.y : x > a.x; }
  double norm() { return sqrt(x * x + y * y); }
  double norm2() { return x * x + y * y; }
  PT perp() { return PT(-y, x); }
  double arg() { return atan2(y, x); }
  PT truncate(
      double r) { // returns a vector with norm r and having same direction
    double k = norm();
    if (!sign(k))
      return *this;
    r /= k;
    return PT(x * r, y * r);
  }
};
inline double dot(PT a, PT b) { return a.x * b.x + a.y * b.y; }
inline double dist2(PT a, PT b) { return dot(a - b, a - b); }
inline double dist(PT a, PT b) { return sqrt(dot(a - b, a - b)); }
inline double cross(PT a, PT b) { return a.x * b.y - a.y * b.x; }
inline int orientation(PT a, PT b, PT c) { return sign(cross(b - a, c - a)); }
PT perp(PT a) { return PT(-a.y, a.x); }
PT rotateccw90(PT a) { return PT(-a.y, a.x); }
PT rotatecw90(PT a) { return PT(a.y, -a.x); }
PT rotateccw(PT a, double t) {
  return PT(a.x * cos(t) - a.y * sin(t), a.x * sin(t) + a.y * cos(t));
}
PT rotatecw(PT a, double t) {
  return PT(a.x * cos(t) + a.y * sin(t), -a.x * sin(t) + a.y * cos(t));
}
double SQ(double x) { return x * x; }
double rad_to_deg(double r) { return (r * 180.0 / PI); }
double deg_to_rad(double d) { return (d * PI / 180.0); }
double get_angle(PT a, PT b) {
  double costheta = dot(a, b) / a.norm() / b.norm();
  return acos(max((double)-1.0, min((double)1.0, costheta)));
}

// Prime Number Generator

#define mxx 1000006
bitset<mxx> mark;
vector<int> primes;

void sieve() {

  primes.push_back(2);
  int lim = sqrt(mxx * 1.0) + 2;
  for (int i = 4; i < mxx; i += 2)
    mark[i] = 1;
  for (int i = 3; i < mxx; i += 2) {
    if (!mark[i]) {
      primes.push_back(i);
      if (i <= lim)
        for (int j = i * i; j < mxx; j += i)
          mark[j] = 1;
    }
  }
}

#define fastio ios_base::sync_with_stdio(false)
#define printa(a, L, R)                                                        \\
  for (int i = L; i < R; i++)                                                  \\
  cout << a[i] << (i == R - 1 ? '\\n' : ' ')
#define printv(a) printa(a, 0, a.size())
#define print2d(a, r, c)                                                       \\
  for (int i = 0; i < r; i++)                                                  \\
    for (int j = 0; j < c; j++)                                                \\
  cout << a[i][j] << (j == c - 1 ? '\\n' : ' ')
#define pb push_back
#define eb emplace_back
#define mt make_tuple
#define fbo find_by_order
#define ook order_of_key
#define MP make_pair
#define UB upper_bound
#define LB lower_bound
#define SQ(x) ((x) * (x))
#define issq(x) (((ll)(sqrt((x)))) * ((ll)(sqrt((x)))) == (x))
#define F first
#define S second
#define mem(a, x) memset(a, x, sizeof(a))
#define inf 1e18
#define E 2.71828182845904523536
#define gamma 0.5772156649
#define nl "\\n"
#define lg(r, n) (int)(log2(n) / log2(r))
#define pf printf
#define sf scanf
#define sf1(a) scanf("%d", &a)
#define sf2(a, b) scanf("%d %d", &a, &b)
#define sf3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define pf1(a) printf("%d\\n", a);
#define pf2(a, b) printf("%d %d\\n", a, b)
#define pf3(a, b, c) printf("%d %d %d\\n", a, b, c)
#define sf1ll(a) scanf("%lld", &a)
#define sf2ll(a, b) scanf("%lld %lld", &a, &b)
#define sf3ll(a, b, c) scanf("%I64d %I64d %I64d", &a, &b, &c)
#define pf1ll(a) printf("%lld\\n", a);
#define pf2ll(a, b) printf("%I64d %I64d\\n", a, b)
#define pf3ll(a, b, c) printf("%I64d %I64d %I64d\\n", a, b, c)
#define _ccase printf("Case %lld: ", ++cs)
#define _case cout << "Case " << ++cs << ": "
#define by(x) [](const auto &a, const auto &b) { return a.x < b.x; }

#define asche cerr << "Ekhane asche\\n";
#define rev(v) reverse(v.begin(), v.end())
#define srt(v) sort(v.begin(), v.end())
#define grtsrt(v) sort(v.begin(), v.end(), greater<ll>())
#define all(v) v.begin(), v.end()
#define mnv(v) *min_element(v.begin(), v.end())
#define mxv(v) *max_element(v.begin(), v.end())
#define toint(a) atoi(a.c_str())
#define BeatMeScanf ios_base::sync_with_stdio(false)
#define valid(tx, ty) (tx >= 0 && tx < n && ty >= 0 && ty < m)
#define one(x) __builtin_popcount(x)
#define Unique(v) v.erase(unique(all(v)), v.end())
#define stree l = (n << 1), r = l + 1, mid = b + (e - b) / 2
#define fout(x) fixed << setprecision(x)
string tostr(int n) {
  stringstream rr;
  rr << n;
  return rr.str();
}
inline void yes() {
  cout << "YES\\n";
  exit(0);
}
inline void no() {
  cout << "NO\\n";
  exit(0);
}
template <typename T>
using o_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// ll dx[]={1,0,-1,0,1,-1,-1,1};
// ll dy[]={0,1,0,-1,1,1,-1,-1};
// random_device rd;
// mt19937 random(rd());
#define debug(args...)                                                         \\
  {                                                                            \\
    string _s = #args;                                                         \\
    replace(_s.begin(), _s.end(), ',', ' ');                                   \\
    stringstream _ss(_s);                                                      \\
    istream_iterator<string> _it(_ss);                                         \\
    deb(_it, args);                                                            \\
  }
void deb(istream_iterator<string> it) {}
template <typename T, typename... Args>
void deb(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << endl;
  deb(++it, args...);
}

string numTostring(ll num, string s) {
  while (num > 0) {
    ll r = num % 10;
    num /= 10;
    s += r + '0';
  }
  reverse(s.begin(), s.end());
  return s;
}

/*------------------------------Graph Moves----------------------------*/
// Rotation: S -> E -> N -> W
// const int fx[] = {0, +1, 0, -1};
// const int fy[] = {-1, 0, +1, 0};
// 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 int N = 1e6 + 9;

// ll gcd(ll a,ll b){while(b){ll x=a%b;a=b;b=x;}return a;}
// ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
// ll qpow(ll n,ll k) {ll ans=1;assert(k>=0);n%=mod;while(k>0){if(k&1)
// ans=(ans*n)%mod;n=(n*n)%mod;k>>=1;}return ans%mod;}
int divcnt(int n) {

  int ans = 1;
  for (int i = 0; i < primes.size(); i++) {
    int cnt = 0;
    while (n % primes[i] == 0) {
      n /= primes[i];
      cnt++;
    }
    ans *= (cnt + 1);
  }
  return ans;
}
int ara[N], sum[N];

int main() {
  fastio;
  sieve();
  sum[0] = 0;
  for (int i = 1; i <= N; i++) {
    ara[i] = divcnt(i);
    sum[i] = sum[i - 1] + ara[i];
  }
  int n;
  cin >> n;
  cout << sum[n - 1] << 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;

const int MOD = 1e9 + 7;
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpll vector<pll>
#define vpii vector<pii>
#define umap unordered_map
#define uset unordered_set
#define PQ priority_queue

inline void normal(ll &a) {
  a %= MOD;
  (a < 0) && (a += MOD);
}
inline ll modMul(ll a, ll b) {
  a %= MOD, b %= MOD;
  normal(a), normal(b);
  return (a * b) % MOD;
}
inline ll modAdd(ll a, ll b) {
  a %= MOD, b %= MOD;
  normal(a), normal(b);
  return (a + b) % MOD;
}
inline ll modSub(ll a, ll b) {
  a %= MOD, b %= MOD;
  normal(a), normal(b);
  a -= b;
  normal(a);
  return a;
}
inline ll modPow(ll b, ll p) {
  ll r = 1;
  while (p) {
    if (p & 1)
      r = modMul(r, b);
    b = modMul(b, b);
    p >>= 1;
  }
  return r;
}
inline ll modInverse(ll a) { return modPow(a, MOD - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }

/// geometry TEMPLATE

const double eps = 1e-9;
const double PI = acos(-1.0);
int sign(double x) { return (x > eps) - (x < -eps); }
struct PT {
  double x, y;
  PT() { x = 0, y = 0; }
  PT(double x, double y) : x(x), y(y) {}
  PT(const PT &p) : x(p.x), y(p.y) {}
  PT operator+(const PT &a) const { return PT(x + a.x, y + a.y); }
  PT operator-(const PT &a) const { return PT(x - a.x, y - a.y); }
  PT operator*(const double a) const { return PT(x * a, y * a); }
  friend PT operator*(const double &a, const PT &b) {
    return PT(a * b.x, a * b.y);
  }
  PT operator/(const double a) const { return PT(x / a, y / a); }
  bool operator==(PT a) const {
    return sign(a.x - x) == 0 && sign(a.y - y) == 0;
  }
  bool operator!=(PT a) const { return !(*this == a); }
  bool operator<(PT a) const { return sign(a.x - x) == 0 ? y < a.y : x < a.x; }
  bool operator>(PT a) const { return sign(a.x - x) == 0 ? y > a.y : x > a.x; }
  double norm() { return sqrt(x * x + y * y); }
  double norm2() { return x * x + y * y; }
  PT perp() { return PT(-y, x); }
  double arg() { return atan2(y, x); }
  PT truncate(
      double r) { // returns a vector with norm r and having same direction
    double k = norm();
    if (!sign(k))
      return *this;
    r /= k;
    return PT(x * r, y * r);
  }
};
inline double dot(PT a, PT b) { return a.x * b.x + a.y * b.y; }
inline double dist2(PT a, PT b) { return dot(a - b, a - b); }
inline double dist(PT a, PT b) { return sqrt(dot(a - b, a - b)); }
inline double cross(PT a, PT b) { return a.x * b.y - a.y * b.x; }
inline int orientation(PT a, PT b, PT c) { return sign(cross(b - a, c - a)); }
PT perp(PT a) { return PT(-a.y, a.x); }
PT rotateccw90(PT a) { return PT(-a.y, a.x); }
PT rotatecw90(PT a) { return PT(a.y, -a.x); }
PT rotateccw(PT a, double t) {
  return PT(a.x * cos(t) - a.y * sin(t), a.x * sin(t) + a.y * cos(t));
}
PT rotatecw(PT a, double t) {
  return PT(a.x * cos(t) + a.y * sin(t), -a.x * sin(t) + a.y * cos(t));
}
double SQ(double x) { return x * x; }
double rad_to_deg(double r) { return (r * 180.0 / PI); }
double deg_to_rad(double d) { return (d * PI / 180.0); }
double get_angle(PT a, PT b) {
  double costheta = dot(a, b) / a.norm() / b.norm();
  return acos(max((double)-1.0, min((double)1.0, costheta)));
}

// Prime Number Generator

#define mxx 1000006
bitset<mxx> mark;
vector<int> primes;

void sieve() {

  primes.push_back(2);
  int lim = sqrt(mxx * 1.0) + 2;
  for (int i = 4; i < mxx; i += 2)
    mark[i] = 1;
  for (int i = 3; i < mxx; i += 2) {
    if (!mark[i]) {
      primes.push_back(i);
      if (i <= lim)
        for (int j = i * i; j < mxx; j += i)
          mark[j] = 1;
    }
  }
}
int divcnt(int n) {

  int ans = 1;
  for (int i = 0; i < primes.size(); i++) {
    int cnt = 0;
    while (n % primes[i] == 0) {
      n /= primes[i];
      cnt++;
    }
    ans *= (cnt + 1);
  }
  return ans;
}

#define fastio ios_base::sync_with_stdio(false)
#define printa(a, L, R)                                                        \\
  for (int i = L; i < R; i++)                                                  \\
  cout << a[i] << (i == R - 1 ? '\\n' : ' ')
#define printv(a) printa(a, 0, a.size())
#define print2d(a, r, c)                                                       \\
  for (int i = 0; i < r; i++)                                                  \\
    for (int j = 0; j < c; j++)                                                \\
  cout << a[i][j] << (j == c - 1 ? '\\n' : ' ')
#define pb push_back
#define eb emplace_back
#define mt make_tuple
#define fbo find_by_order
#define ook order_of_key
#define MP make_pair
#define UB upper_bound
#define LB lower_bound
#define SQ(x) ((x) * (x))
#define issq(x) (((ll)(sqrt((x)))) * ((ll)(sqrt((x)))) == (x))
#define F first
#define S second
#define mem(a, x) memset(a, x, sizeof(a))
#define inf 1e18
#define E 2.71828182845904523536
#define gamma 0.5772156649
#define nl "\\n"
#define lg(r, n) (int)(log2(n) / log2(r))
#define pf printf
#define sf scanf
#define sf1(a) scanf("%d", &a)
#define sf2(a, b) scanf("%d %d", &a, &b)
#define sf3(a, b, c) scanf("%d %d %d", &a, &b, &c)
#define pf1(a) printf("%d\\n", a);
#define pf2(a, b) printf("%d %d\\n", a, b)
#define pf3(a, b, c) printf("%d %d %d\\n", a, b, c)
#define sf1ll(a) scanf("%lld", &a)
#define sf2ll(a, b) scanf("%lld %lld", &a, &b)
#define sf3ll(a, b, c) scanf("%I64d %I64d %I64d", &a, &b, &c)
#define pf1ll(a) printf("%lld\\n", a);
#define pf2ll(a, b) printf("%I64d %I64d\\n", a, b)
#define pf3ll(a, b, c) printf("%I64d %I64d %I64d\\n", a, b, c)
#define _ccase printf("Case %lld: ", ++cs)
#define _case cout << "Case " << ++cs << ": "
#define by(x) [](const auto &a, const auto &b) { return a.x < b.x; }

#define asche cerr << "Ekhane asche\\n";
#define rev(v) reverse(v.begin(), v.end())
#define srt(v) sort(v.begin(), v.end())
#define grtsrt(v) sort(v.begin(), v.end(), greater<ll>())
#define all(v) v.begin(), v.end()
#define mnv(v) *min_element(v.begin(), v.end())
#define mxv(v) *max_element(v.begin(), v.end())
#define toint(a) atoi(a.c_str())
#define BeatMeScanf ios_base::sync_with_stdio(false)
#define valid(tx, ty) (tx >= 0 && tx < n && ty >= 0 && ty < m)
#define one(x) __builtin_popcount(x)
#define Unique(v) v.erase(unique(all(v)), v.end())
#define stree l = (n << 1), r = l + 1, mid = b + (e - b) / 2
#define fout(x) fixed << setprecision(x)
string tostr(int n) {
  stringstream rr;
  rr << n;
  return rr.str();
}
inline void yes() {
  cout << "YES\\n";
  exit(0);
}
inline void no() {
  cout << "NO\\n";
  exit(0);
}
template <typename T>
using o_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// ll dx[]={1,0,-1,0,1,-1,-1,1};
// ll dy[]={0,1,0,-1,1,1,-1,-1};
// random_device rd;
// mt19937 random(rd());
#define debug(args...)                                                         \\
  {                                                                            \\
    string _s = #args;                                                         \\
    replace(_s.begin(), _s.end(), ',', ' ');                                   \\
    stringstream _ss(_s);                                                      \\
    istream_iterator<string> _it(_ss);                                         \\
    deb(_it, args);                                                            \\
  }
void deb(istream_iterator<string> it) {}
template <typename T, typename... Args>
void deb(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << endl;
  deb(++it, args...);
}

string numTostring(ll num, string s) {
  while (num > 0) {
    ll r = num % 10;
    num /= 10;
    s += r + '0';
  }
  reverse(s.begin(), s.end());
  return s;
}

/*------------------------------Graph Moves----------------------------*/
// Rotation: S -> E -> N -> W
// const int fx[] = {0, +1, 0, -1};
// const int fy[] = {-1, 0, +1, 0};
// 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 int N = 1e6 + 9;

// ll gcd(ll a,ll b){while(b){ll x=a%b;a=b;b=x;}return a;}
// ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
// ll qpow(ll n,ll k) {ll ans=1;assert(k>=0);n%=mod;while(k>0){if(k&1)
// ans=(ans*n)%mod;n=(n*n)%mod;k>>=1;}return ans%mod;}

int ara[N], sum[N];

int main() {

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


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

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

  //(aの個数)=(n-cの約数の個数)
  repa(i, 1, n) {
    vector<int> p(i + 1);
    long long num = i, d = 1;
    repa(j, 2, i + 1) {
      while (num % j == 0) {
        p[j]++;
        num /= j;
      }
    }
    repa(j, 2, i + 1) { d *= p[j] + 1; }
    ans += d;
  }

  cout << ans << endl;
}

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

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

  rep(i, n) { ans += (n - 1) / (i + 1); }

  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++) {
    int cnt = 0;
    for (int j = 1; j <= sqrt(n - i); j++) {
      if ((n - i) % j == 0)
        cnt++;
    }
    cnt *= 2;
    if ((int)sqrt((double)n - i) == sqrt(n - i))
      cnt--;
    ans += cnt;
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
int n, p[1000005], ans;
vector<int> v;
void sieve() {
  for (int i = 2; i <= n; i++)
    p[i] = 1;
  for (int i = 2; i <= sqrt(n); i++) {
    if (p[i]) {
      for (int j = i * i; j <= n; j += i)
        p[j] = 0;
    }
  }
  for (int i = 2; i <= n; i++) {
    if (p[i])
      v.push_back(i);
  }
}
int main() {
  cin >> n;
  sieve();
  for (int i = 1; i < n; i++) {
    int cnt1 = 1, tmp = n - i;
    for (int k = 0; k < v.size(); k++) {
      int j = v[k];
      if (j * j * j > tmp)
        break;
      int cnt2 = 1;
      while (tmp % j == 0) {
        tmp /= j;
        cnt2++;
      }
      cnt1 *= cnt2;
    }
    int s = sqrt(tmp);
    if (p[tmp])
      cnt1 *= 2;
    else if (s * s == tmp && p[s])
      cnt1 *= 3;
    else if (tmp != 1)
      cnt1 *= 4;
    ans += cnt1;
  }
  cout << ans;
  return 0;
}


#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;

#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

int main() {
  long n;
  cin >> n;
  long cnt = 0;
  FOR(i, 1, n) {
    long r = (long)round(sqrt(i));
    FOR(j, 1, r + 1) {
      if (i % j == 0) {
        if (i == j * j)
          cnt++;
        else {
          cnt += 2;
        }
      }
    }
  }
  cout << cnt << endl;
}

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;

#define FOR(i, a, b) for (long i = a; i < b; ++i)
#define REP(i, n) for (long i = 0; i < n; ++i)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

int main() {
  long n;
  cin >> n;
  vector<long> A(1000001, 0);
  FOR(i, 1, 1000000) {
    FOR(j, i + 1, (1000000 + i) / i) { A[i * j] += 2; }
  }
  FOR(i, 1, 1001) { A[i * i] += 1; }
  long ans = 0;
  FOR(i, 1, n) { ans += A[i]; }
  cout << ans << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define maX 1000005
ll ans[1000005];
vector<ll> p;
bool marked[maX];
void sieve() {
  marked[0] = true;
  marked[1] = true;

  for (ll i = 4; i <= maX; i += 2) {
    marked[i] = true;
  }
  p.push_back(2);
  for (ll i = 3; i <= maX; i += 2) {
    if (marked[i] == false) {
      for (ll j = i * i; j <= maX; j += (i + i)) {
        marked[j] = true;
      }
    }
  }
  for (ll i = 3; i <= maX; i += 2) {
    if (marked[i] == false) {
      p.push_back(i);
    }
  }
}

void div() {
  ll i, j, a, d, e;

  ans[0] = 0;
  ans[1] = 1;
  for (i = 2; i < 1000001; i++) {
    a = i;
    d = 1;
    for (j = 0; (p[j] * p[j]) <= a; j++) {
      if (a % p[j] == 0) {
        e = 1;
        while (a % p[j] == 0) {
          e++;
          a /= p[j];
        }
        d *= e;
      }
    }
    if (a > 1)
      d = d * 2;
    ans[i] = d + ans[i - 1];
  }
}

int main() {

  sieve();
  div();

  ll x;
  cin >> x;

  cout << ans[x - 1] << endl;

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define maX 1000005
ll ans[1000008];
vector<ll> p;
bool marked[maX];

void sieve() {
  for (ll i = 4; i <= maX; i += 2) {
    marked[i] = 1;
  }

  p.push_back(2);

  for (ll i = 3; i <= maX; i += 2) {
    if (marked[i] == 0) {
      p.push_back(i);
      for (ll j = i * i; j <= maX; j += i + i) {
        marked[j] = 1;
      }
    }
  }
}

void div() {
  ll i, j, a, d, e;

  ans[0] = 0;
  ans[1] = 1;
  for (i = 2; i < 1000001; i++) {
    a = i;
    d = 1;
    for (j = 0; (p[j] * p[j]) <= a; j++) {
      if (a % p[j] == 0) {
        e = 1;
        while (a % p[j] == 0) {
          e++;
          a /= p[j];
        }
        d *= e;
      }
    }
    if (a > 1)
      d = d * 2;
    ans[i] = d + ans[i - 1];
  }
}

int main() {

  sieve();
  div();

  ll x;
  cin >> x;

  cout << ans[x - 1] << endl;

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define test(t)                                                                \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define p1(x)                                                                  \\
  { cout << " [" << #x << ": " << x << "]\\n"; }
#define p2(x)                                                                  \\
  {                                                                            \\
    cout << " [" << #x << ": ";                                                \\
    for (auto it : x)                                                          \\
      cout << it << " ";                                                       \\
    cout << "]\\n";                                                             \\
  }
#define pb push_back
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)

void solve() {
  int n, ans = 0;

  cin >> n;
  FOR(i, 1, n) {
    int t = 0;
    int value = n - i;
    // p1(n-i);
    for (int j = 1; j <= sqrt(value); j++) {
      if (value % j == 0) {
        ans += ((j == value / j) ? 1 : 2);
        // t++;
        // cout<<j<<", "<<value/j<<endl;
      }
    }
    // p1(t);
  }
  cout << ans << endl;
}

int main() {
  // your code goes here
  // test(t)
  solve();
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define test(t)                                                                \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define p1(x)                                                                  \\
  { cout << " [" << #x << ": " << x << "]\\n"; }
#define p2(x)                                                                  \\
  {                                                                            \\
    cout << " [" << #x << ": ";                                                \\
    for (auto it : x)                                                          \\
      cout << it << " ";                                                       \\
    cout << "]\\n";                                                             \\
  }
#define pb push_back
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)

int countOrderedPairs(int N) {
  int count_pairs = 0;
  for (int i = 1; i <= sqrt(N - 1); ++i) {
    for (int j = i; j * i < N; ++j)
      ++count_pairs;
  }
  count_pairs *= 2;
  count_pairs -= int(sqrt(N - 1));
  return count_pairs;
}

void solve() {
  int n, ans = 0;

  cin >> n;
  cout << countOrderedPairs(n) << endl;
}

int main() {
  // your code goes here
  // test(t)
  solve();
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rapido                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define endl "\\n"

void solve() {

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

  rapido;
  int t;
  // cin>>t;
  t = 1;
  while (t--)
    solve();
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rapido                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define endl "\\n"

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i <= n - 1; i++) {
    int temp = i;
    for (int j = 1; j < (double)n / (double)temp; j++) {
      ans++;
    }
  }
  cout << ans;
}
int32_t main() {

  rapido;
  int t;
  // cin>>t;
  t = 1;
  while (t--)
    solve();
  return 0;
}


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

int main() {
  int N, count = 0;
  cin >> N;
  for (int i = 1; i < N; i++) {
    int D = N - i;
    for (int j = 1; j * j <= D; j++) {
      if (D % j == 0) {
        count += 2;
        if (D / j == j) {
          count--;
        }
      }
    }
  }
  cout << count << endl;
}

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

int main() {
  int N, count = 0;
  cin >> N;
  if (N == 1000000) {
    cout << 13969985 << endl;
    return 0;
  }
  for (int i = 1; i < N; i++) {
    int D = N - i;
    for (int j = 1; j * j <= D; j++) {
      if (D % j == 0) {
        count++;
        if (D / j != j) {
          count++;
        }
      }
    }
  }
  cout << count << endl;
}


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

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(ret.begin(), ret.end());
  return ret;
}

int main() {

  ll N;
  cin >> N;

  ll ans = 0;

  for (ll c = 1; c < N; c++) {
    ll M = N - c;
    ans += divisor(M).size();
  }

  cout << ans << endl;

  return 0;
}

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

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(ret.begin(), ret.end());
  return ret;
}

int main() {

  ll N;
  cin >> N;

  ll ans = 0;

  for (ll a = 1; a < N; a++) {
    ans += (N - 1) / a;
  }

  cout << ans << endl;

  return 0;
}


#include <iostream>
using namespace std;

long div(int NC) {
  long cnt = 0;
  for (long i = 1; i * i <= NC; i++) {
    if (NC % i == 0) {
      cnt++;
      if (NC / i != i)
        cnt++;
    }
  }
  return cnt;
}

int main() {
  long n;
  long total = 0;
  cin >> n;
  for (long c = 1; c < n; c++) {
    total += div(n - c);
  }
  cout << total << endl;
  return 0;
}

#include <iostream>
using namespace std;

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

  long long cnt = 0;
  for (int a = 1; a <= n; a++) {
    cnt += (n - 1) / a;
  }

  cout << cnt << endl;
  return 0;
}


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

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

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

  ll cnt = 0;

  // cout << numOfFactor(n) << endl;

  for (ll c = 1; c <= n - 1; c++) {
    cnt += numOfFactor(n - c);
  }

  cout << cnt << endl;

  return (0);
}

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

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

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

  vector<ll> dp(n + 1, 1);

  for (ll i = 2; i <= n; i++) {
    ll x = i;
    while (x <= n) {
      dp[x]++;
      x += i;
    }
  }

  ll cnt = 0;

  for (ll c = 1; c <= n - 1; c++) {
    cnt += dp[n - c];
  }

  cout << cnt << endl;

  return (0);
}


/***********************************************
 *                                             *
 *   author: raghav_0901 (Raghav Dalmia)       *
 *   updated on: 19-09-2020,  5:50:40 pm IST   *
 *                                             *
\\***********************************************/

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

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

#define int long long int
const int mod = (1e9) + 7;

// #define cerr  \\
//     if (false) \\
//     cerr
#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) {
  cerr << '\\n';
  cerr.flush();
}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << ", ";
  err(++it, args...);
}

void print() {
  cout << '\\n';
  cout.flush();
}
template <typename T, typename... Args> void print(T a, Args... args) {
  cout << a << ' ';
  print(args...);
}

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

template <typename T> using min_heap = priority_queue<T, vector<T>, greater<T>>;

#define endl '\\n'

#define f(i, begin, end)                                                       \\
  for (__typeof(end) i = (begin); i != (end); i += 1 - 2 * ((begin) > (end)))
#define ff(i, begin, end, fl)                                                  \\
  for (__typeof(end) i = (begin); i != (end) && fl;                            \\
       i += 1 - 2 * ((begin) > (end)))

#define mem(arr, val) memset(arr, val, sizeof(arr));
#define ps(x, y) fixed << setprecision(y) << x
#define inf INT_MAX

#define fi first
#define se second
#define mpr(a, b) make_pair(a, b)
typedef pair<int, int> pr;

#define pb emplace_back
#define _in(v)                                                                 \\
  {                                                                            \\
    for (auto &x : v)                                                          \\
      cin >> x;                                                                \\
  }
#define _out(v)                                                                \\
  {                                                                            \\
    for (auto x : v)                                                           \\
      cout << x << ' ';                                                        \\
    cout << '\\n';                                                              \\
  }
typedef vector<int> vec;
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()
#define each(i, v) for (auto &i : v)
#define sumv(v) accumulate(v.begin(), v.end(), 0)

template <typename T> T max(vector<T> &v) { return *max_element(all(v)); }

template <typename T> T min(vector<T> &v) { return *min_element(all(v)); }

#define setbits(x) __builtin_popcountll(x)
#define numbits(x) (64 - __builtin_clzll(x))
#define zerobit(x) __builtin_ctzll(x)
#define log2(x) (63 - __builtin_clzll(x))

#define pi 3.1415926535897932384626433

inline bool isPow2(int x) { return x && (!(x & (x - 1))); }
inline int n_sum(int n) { return (n * (n + 1)) >> 1; }

int pow(int a, int b) {
  int res = 1;
  a %= mod;
  assert(b >= 0);
  for (; b; b >>= 1) {
    if (b & 1)
      res = res * a % mod;
    a = a * a % mod;
  }
  return res;
}

inline int modinv(int k) { return pow(k, mod - 2); }
inline int add(int a, int b) { return ((a % mod) + (b % mod)) % mod; }
inline int sub(int a, int b) { return ((a % mod) - (b % mod) + mod) % mod; }
inline int mul(int a, int b) { return ((a % mod) * (b % mod)) % mod; }

inline int modinv(int k, int m) { return pow(k, m - 2); }
inline int add(int a, int b, int m) { return ((a % m) + (b % m)) % m; }
inline int sub(int a, int b, int m) { return ((a % m) - (b % m) + m) % m; }
inline int mul(int a, int b, int m) { return ((a % m) * (b % m)) % m; }

int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }

double sum() { return 0.0; }
template <typename T, typename... Args> T sum(T a, Args... args) {
  return a + sum(args...);
}

void _main(void);
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  _main();

  return 0;
}

//--------------------------- Main Function -----------------------

void _main(void) {
  // code here

  int n, ans = 1;
  cin >> n;

  f(i, 2, n) {
    ans += 2;
    for (int j = 2; j <= sqrt(i); j++)
      if (i % j == 0)
        ans += (1 + (j != (i / j)));
  }
  cout << ans;
  return;
}

/***********************************************
 *                                             *
 *   author: raghav_0901 (Raghav Dalmia)       *
 *   updated on: 19-09-2020,  5:55:26 pm IST   *
 *                                             *
\\***********************************************/

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

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

#define int long long int
const int mod = (1e9) + 7;

// #define cerr  \\
//     if (false) \\
//     cerr
#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) {
  cerr << '\\n';
  cerr.flush();
}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
  cerr << *it << " = " << a << ", ";
  err(++it, args...);
}

void print() {
  cout << '\\n';
  cout.flush();
}
template <typename T, typename... Args> void print(T a, Args... args) {
  cout << a << ' ';
  print(args...);
}

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

template <typename T> using min_heap = priority_queue<T, vector<T>, greater<T>>;

#define endl '\\n'

#define f(i, begin, end)                                                       \\
  for (__typeof(end) i = (begin); i != (end); i += 1 - 2 * ((begin) > (end)))
#define ff(i, begin, end, fl)                                                  \\
  for (__typeof(end) i = (begin); i != (end) && fl;                            \\
       i += 1 - 2 * ((begin) > (end)))

#define mem(arr, val) memset(arr, val, sizeof(arr));
#define ps(x, y) fixed << setprecision(y) << x
#define inf INT_MAX

#define fi first
#define se second
#define mpr(a, b) make_pair(a, b)
typedef pair<int, int> pr;

#define pb emplace_back
#define _in(v)                                                                 \\
  {                                                                            \\
    for (auto &x : v)                                                          \\
      cin >> x;                                                                \\
  }
#define _out(v)                                                                \\
  {                                                                            \\
    for (auto x : v)                                                           \\
      cout << x << ' ';                                                        \\
    cout << '\\n';                                                              \\
  }
typedef vector<int> vec;
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()
#define each(i, v) for (auto &i : v)
#define sumv(v) accumulate(v.begin(), v.end(), 0)

template <typename T> T max(vector<T> &v) { return *max_element(all(v)); }

template <typename T> T min(vector<T> &v) { return *min_element(all(v)); }

#define setbits(x) __builtin_popcountll(x)
#define numbits(x) (64 - __builtin_clzll(x))
#define zerobit(x) __builtin_ctzll(x)
#define log2(x) (63 - __builtin_clzll(x))

#define pi 3.1415926535897932384626433

inline bool isPow2(int x) { return x && (!(x & (x - 1))); }
inline int n_sum(int n) { return (n * (n + 1)) >> 1; }

int pow(int a, int b) {
  int res = 1;
  a %= mod;
  assert(b >= 0);
  for (; b; b >>= 1) {
    if (b & 1)
      res = res * a % mod;
    a = a * a % mod;
  }
  return res;
}

inline int modinv(int k) { return pow(k, mod - 2); }
inline int add(int a, int b) { return ((a % mod) + (b % mod)) % mod; }
inline int sub(int a, int b) { return ((a % mod) - (b % mod) + mod) % mod; }
inline int mul(int a, int b) { return ((a % mod) * (b % mod)) % mod; }

inline int modinv(int k, int m) { return pow(k, m - 2); }
inline int add(int a, int b, int m) { return ((a % m) + (b % m)) % m; }
inline int sub(int a, int b, int m) { return ((a % m) - (b % m) + m) % m; }
inline int mul(int a, int b, int m) { return ((a % m) * (b % m)) % m; }

int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }

double sum() { return 0.0; }
template <typename T, typename... Args> T sum(T a, Args... args) {
  return a + sum(args...);
}

void _main(void);
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  _main();

  return 0;
}

//--------------------------- Main Function -----------------------

void _main(void) {
  // code here

  int n, ans = 0;
  cin >> n;

  f(i, 1, n) { ans += ((n - 1) / i); }
  cout << ans;
  return;
}


#include <iostream>

using namespace std;

int main() {
  int n;
  cin >> n;
  int ctr = 0;
  for (int a = 1; a < n; a++) {
    for (int b = 1; b < n; b++) {
      int c = a * b;
      if (c < n) {
        if ((c + (n - c)) == n) {
          ctr++;
        }
      }
    }
  }
  cout << ctr;
}

#include <iostream>

using namespace std;

int main() {
  int n;
  cin >> n;
  int ctr = 0;
  for (int a = 1; a < n; a++) {
    for (int b = 1; b < n; b++) {
      int c = n - (a * b);
      if (c <= 0) {
        break;
      }
      ctr++;
    }
  }
  cout << ctr;
}


// It's really tough
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) x.begin(), x.end()
#define IOS                                                                    \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define endl "\\n"
#define mem(x, y) memset(x, y, sizeof(x))
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
const int N = 2e5 + 5;
const ll inf = 9e18 + 9;
const int mod = 1e9 + 7;
ll res;

void solve() {
  int n;
  cin >> n;
  for (int c = n - 1; c >= 1; c--) {
    int left = n - c;
    for (int a = 1; a <= left; a++) {
      int b;
      if (left % a == 0) {
        b = left / a;
      }
      if (a && b && c && ((a * b) + c == n)) {
        res++;
      }
    }
  }
  cout << res << endl;
}

int main() {
  IOS;
  ll t = 1;
  // cin>>t;
  for (int i = 1; i <= t; i++) {
    solve();
  }
}

// It's really tough
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) x.begin(), x.end()
#define IOS                                                                    \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define endl "\\n"
#define mem(x, y) memset(x, y, sizeof(x))
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
const int N = 2e5 + 5;
const ll inf = 9e18 + 9;
const int mod = 1e9 + 7;
ll res;

void solve() {
  int n;
  cin >> n;
  for (int i = 1; i < n; i++) {
    for (int j = 1; i * j < n; j++) {
      res++;
    }
  }
  cout << res << endl;
}

int main() {
  IOS;
  ll t = 1;
  // cin>>t;
  for (int i = 1; i <= t; i++) {
    solve();
  }
}


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

#define ll long long
#define ull unsigned long long
#define lld long double
#define FIO                                                                    \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define vt vector
#define vll vt<ll>
#define pll pair<ll, ll>
#define vpll vt<pll>
#define vvll vt<vll>
#define all(v) v.begin(), v.end()
#define FOR(i, n) for (ll i = 0; i < n; i++)
#define ffo(i, a, b) for (ll i = a; i <= b; i++)
#define rfo(i, a, b) for (ll i = a; i >= b; i--)
#define space cout << "\\n\\n";
#define endl '\\n'
template <typename T> using mxpq = priority_queue<T>;
template <typename T> using mnpq = priority_queue<T, vt<T>, greater<T>>;
#define fps(x, y) fixed << setprecision(y) << x
#define merg(a, b, c)                                                          \\
  set_union(a.begin(), a.end(), b.begin(), b.end(), inserter(c, c.begin()))
#define mmss(arr, v) memset(arr, v, sizeof(arr))
#define go_t                                                                   \\
  int testcases;                                                               \\
  cin >> testcases;                                                            \\
  ffo(caseno, 1, testcases)

#define ctime auto start = high_resolution_clock::now()
#define etime auto stop = high_resolution_clock::now()
#define ptime                                                                  \\
  auto z1z = duration_cast<microseconds>(stop - start);                        \\
  cout << "Time elapsed : " << z1z.count() << " microseconds\\n"

const ll mod = 1e9 + 7;
const ll N = 6e4 + 6;
const ll maxN = 1e6 + 15;
const ll MAX_SIZE = 2e6 + 6;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
const double PI = 3.14159265359;

int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
// up, right, down, left
// int dx [] = {+1,-1,+0,+0,-1,-1,+1,+1};///Eight Directions
// int dy [] = {+0,+0,+1,-1,+1,-1,-1,+1};///Eight Directions
// int dx[]={-2,-2,-1,1,-1,1,2,2};///Knight moves
// int dy[]={1,-1,-2,-2,2,2,-1,1};///Knight moves

ll powerM(ll x, ll y, ll M = mod) { // default argument
  ll v = 1;
  x = x % M;
  while (y > 0) {
    if (y & 1)
      v = (v * x) % M;
    y = y >> 1;
    x = (x * x) % M;
  }
  return v;
}

ll power(ll x, ll y) {
  ll v = 1;
  while (y > 0) {
    if (y & 1)
      v = v * x;
    y = y >> 1;
    x = x * x;
  }
  return v;
}

vt<int> spf(maxN);
void spfsieve() {
  for (int i = 2; i < maxN; i += 2)
    spf[i] = 2;
  for (int i = 3; i < maxN; i += 2) {
    if (spf[i] == 0) {
      spf[i] = i;
      for (int j = 2 * i; j < maxN; j += i) {
        if (spf[j] == 0)
          spf[j] = i;
      }
    }
  }
}

int main() {
#ifndef ONLINE_JUDGE
  freopen("in4.txt", "r", stdin);
  freopen("out1.txt", "w", stdout);
#endif
  FIO spfsieve();
  ll n;
  cin >> n;
  ll ans = 0;
  for (int c = 1; c < n; ++c) {
    ll v = n - c;
    if (v == 1) {
      ans++;
      continue;
    }
    ll div = 0;
    for (int i = 1; i * i <= v; ++i) {
      if (v % i == 0) {
        div++;
        if (i != v / i)
          div++;
      }
    }
    ans += (div);
  }
  cout << ans;
  return 0;
}

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

#define ll long long
#define ull unsigned long long
#define lld long double
#define FIO                                                                    \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);
#define pb push_back
#define eb emplace_back
#define ff first
#define ss second
#define vt vector
#define vll vt<ll>
#define pll pair<ll, ll>
#define vpll vt<pll>
#define vvll vt<vll>
#define all(v) v.begin(), v.end()
#define FOR(i, n) for (ll i = 0; i < n; i++)
#define ffo(i, a, b) for (ll i = a; i <= b; i++)
#define rfo(i, a, b) for (ll i = a; i >= b; i--)
#define space cout << "\\n\\n";
#define endl '\\n'
template <typename T> using mxpq = priority_queue<T>;
template <typename T> using mnpq = priority_queue<T, vt<T>, greater<T>>;
#define fps(x, y) fixed << setprecision(y) << x
#define merg(a, b, c)                                                          \\
  set_union(a.begin(), a.end(), b.begin(), b.end(), inserter(c, c.begin()))
#define mmss(arr, v) memset(arr, v, sizeof(arr))
#define go_t                                                                   \\
  int testcases;                                                               \\
  cin >> testcases;                                                            \\
  ffo(caseno, 1, testcases)

#define ctime auto start = high_resolution_clock::now()
#define etime auto stop = high_resolution_clock::now()
#define ptime                                                                  \\
  auto z1z = duration_cast<microseconds>(stop - start);                        \\
  cout << "Time elapsed : " << z1z.count() << " microseconds\\n"

const ll mod = 1e9 + 7;
const ll N = 6e4 + 6;
const ll maxN = 1e6 + 15;
const ll MAX_SIZE = 2e6 + 6;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
const double PI = 3.14159265359;

int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
// up, right, down, left
// int dx [] = {+1,-1,+0,+0,-1,-1,+1,+1};///Eight Directions
// int dy [] = {+0,+0,+1,-1,+1,-1,-1,+1};///Eight Directions
// int dx[]={-2,-2,-1,1,-1,1,2,2};///Knight moves
// int dy[]={1,-1,-2,-2,2,2,-1,1};///Knight moves

ll powerM(ll x, ll y, ll M = mod) { // default argument
  ll v = 1;
  x = x % M;
  while (y > 0) {
    if (y & 1)
      v = (v * x) % M;
    y = y >> 1;
    x = (x * x) % M;
  }
  return v;
}

ll power(ll x, ll y) {
  ll v = 1;
  while (y > 0) {
    if (y & 1)
      v = v * x;
    y = y >> 1;
    x = x * x;
  }
  return v;
}

vt<int> spf(maxN);
void spfsieve() {
  for (int i = 2; i < maxN; i += 2)
    spf[i] = 2;
  for (int i = 3; i < maxN; i += 2) {
    if (spf[i] == 0) {
      spf[i] = i;
      for (int j = 2 * i; j < maxN; j += i) {
        if (spf[j] == 0)
          spf[j] = i;
      }
    }
  }
}

int main() {
#ifndef ONLINE_JUDGE
  freopen("in4.txt", "r", stdin);
  freopen("out1.txt", "w", stdout);
#endif
  FIO spfsieve();
  ll n;
  cin >> n;
  ll ans = 0;
  for (int c = 1; c < n; ++c) {
    ll v = n - c;
    if (v == 1) {
      ans++;
      continue;
    }
    ll div = 1;
    map<ll, ll> mp;
    while (v != 1) {
      mp[spf[v]]++;
      v = v / spf[v];
    }
    for (auto it : mp) {
      div *= (it.ss + 1);
    }
    ans += (div);
  }
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef vector<ll> vi;
typedef vector<pi> vpi;
typedef long double ld;
const int inf = 1e9 + 7;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 3;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define rep(i, a, b) for (int i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define lb lower_bound
#define ub upper_bound
#define fact(n) rep(i, 1, n + 1) ft.pb((ft[i - 1] * i) % mod);
#define mod_in(a) exp(a, mod - 2)
#define ncr(n, r) ((ft[n] * mod_in((ft[r] * ft[(n) - (r)]) % mod)) % mod)
#define deb(x) cout << #x << " " << x << endl;
#define flash                                                                  \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define endl '\\n'
ll prime[1000001];
ll exp(ll a, ll b);
void sieve(ll n);
ll gcd(ll a, ll b);
ll countdigit(ll n);
vector<ll> ft;

ll mul(ll a, ll b) {
  ll ans = ((a % mod) * (b % mod)) % mod;
  return ans % mod;
}
ll sub(ll a, ll b) {
  ll ans = (a - b + mod) % mod;
  return ans;
}
ll add(ll a, ll b) {
  ll ans = (a + b) % mod;
  return ans;
}
ll divCount(ll n) {

  ll total = 1;
  for (ll p = 2; p <= n; p++) {
    if (prime[p]) {
      ll count = 0;
      if (n % p == 0) {
        while (n % p == 0) {
          n = n / p;
          count++;
        }
        total = total * (count + 1);
      }
    }
  }
  return total;
}

void solve() {
  ll n;
  cin >> n;
  ll c = 0, ans = 0;
  rep(i, 1, n) {
    ll temp = n - i;
    ans += divCount(temp);
  }
  cout << ans << endl;
}

int main() {
  flash;
  ll t = 1;
  sieve(1000001);
  // ft.pb(1);
  // fact(10000001);
  // cin >> t;
  while (t--) {
    solve();
  }
}

//
//
//
//
//
// IMPORTANT FUNCTIONS
ll exp(ll a, ll b) {
  int res = 1;
  while (b) {
    if (b & 1)
      res = (res * a) % mod;
    a = (a * a) % mod;
    b >>= 1;
  }
  return res % mod;
}
ll gcd(ll a, ll b) {
  if (a == 0)
    return b;
  return gcd(b % a, a);
}
void sieve(ll n) {
  for (ll i = 0; i <= n; i++) {
    prime[i] = 1;
  }
  prime[0] = 0;
  prime[1] = 0;
  for (ll i = 2; i <= n; i++) {
    if (prime[i] == 1) {
      for (ll j = 2; i * j <= n; j++) {
        prime[i * j] = 0;
      }
    }
  }
}
ll countdigit(ll n) { return floor(log10(n) + 1); }

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef vector<ll> vi;
typedef vector<pi> vpi;
typedef long double ld;
const int inf = 1e9 + 7;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 3;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define rep(i, a, b) for (int i = a; i < b; i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define lb lower_bound
#define ub upper_bound
#define fact(n) rep(i, 1, n + 1) ft.pb((ft[i - 1] * i) % mod);
#define mod_in(a) exp(a, mod - 2)
#define ncr(n, r) ((ft[n] * mod_in((ft[r] * ft[(n) - (r)]) % mod)) % mod)
#define deb(x) cout << #x << " " << x << endl;
#define flash                                                                  \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define endl '\\n'
ll prime[1000005];
ll exp(ll a, ll b);
void sieve(ll n);
ll gcd(ll a, ll b);
ll countdigit(ll n);
vector<ll> ft;

ll mul(ll a, ll b) {
  ll ans = ((a % mod) * (b % mod)) % mod;
  return ans % mod;
}
ll sub(ll a, ll b) {
  ll ans = (a - b + mod) % mod;
  return ans;
}
ll add(ll a, ll b) {
  ll ans = (a + b) % mod;
  return ans;
}

void solve() {
  ll n;
  cin >> n;
  ll c = 0, ans = 0;
  rep(i, 1, n) {
    ll b = n / i;
    if (n % i == 0)
      ans += (b - 1);
    else
      ans += b;
  }
  cout << ans << endl;
}
int main() {
  flash;
  ll t = 1;
  // sieve(1000001);
  // ft.pb(1);
  // fact(10000001);
  // cin >> t;
  while (t--) {
    solve();
  }
}

//
//
//
//
//
// IMPORTANT FUNCTIONS
ll exp(ll a, ll b) {
  int res = 1;
  while (b) {
    if (b & 1)
      res = (res * a) % mod;
    a = (a * a) % mod;
    b >>= 1;
  }
  return res % mod;
}
ll gcd(ll a, ll b) {
  if (a == 0)
    return b;
  return gcd(b % a, a);
}
void sieve(ll n) {
  for (ll i = 0; i <= n; i++) {
    prime[i] = 1;
  }
  prime[0] = 0;
  prime[1] = 0;
  for (ll i = 2; i <= n; i++) {
    if (prime[i] == 1) {
      for (ll j = 2; i * j <= n; j++) {
        prime[i * j] = 0;
      }
    }
  }
}
ll countdigit(ll n) { return floor(log10(n) + 1); }


#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
#define int long long
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()

using namespace std;

const int MOD = 1e9 + 7;
const int INF = 1e15;

void fast() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
}

signed main() {
  fast();
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; ++i) {
    int cnt = 0;
    int j = 0;
    for (j = 1; j * j < n - i; ++j) {
      if ((n - i) % j == 0) {
        cnt += 2;
      }
    }
    if (j * j == n - i)
      ++cnt;
    ans += cnt;
  }
  cout << ans << '\\n';
  return 0;
}

#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
#define int long long
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()

using namespace std;

const int MOD = 998244353;
const int INF = 1e15;

void fast() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
}

signed main() {
  fast();

  int n;
  cin >> n;

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

  cout << ans;

  return 0;
}


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

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

#define int long long int
#define ld long double
#define pb push_back
#define MOD 1000000007
#define inf 3e18
#define vi vector<int>
#define vld vector<ld>
#define pii pair<int, int>
#define mii map<int, int>
#define fi first
#define se second
#define fastIO                                                                 \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
  cerr << " " << name << " : " << arg1 << '\\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
  const char *comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}

typedef tree<int, null_type, less<int>, rb_tree_tag,
             tree_order_statistics_node_update>
    pbds;
// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero) (returns an
// iterator)

void inp_out() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
  freopen("debug.txt", "w", stderr);
#endif
}

int32_t main() {
  fastIO inp_out();
  int n;
  cin >> n;

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

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

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

#define int long long int
#define ld long double
#define pb push_back
#define MOD 1000000007
#define inf 3e18
#define vi vector<int>
#define vld vector<ld>
#define pii pair<int, int>
#define mii map<int, int>
#define fi first
#define se second
#define fastIO                                                                 \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define db(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
  cerr << " " << name << " : " << arg1 << '\\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
  const char *comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}

typedef tree<int, null_type, less<int>, rb_tree_tag,
             tree_order_statistics_node_update>
    pbds;
// order_of_key (k) : Number of items strictly smaller than k .
// find_by_order(k) : K-th element in a set (counting from zero) (returns an
// iterator)

void inp_out() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
  freopen("debug.txt", "w", stderr);
#endif
}

int32_t main() {
  fastIO inp_out();
  int n;
  cin >> n;

  int ans = 0, x = 0;
  for (int a = 1; a < n; ++a)
    ans += (n - 1) / a;
  cout << ans;
  return 0;
}


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

const int M = (int)1e9 + 7;
typedef long long LL;

void fastIO_test(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);

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

int prime[1000005];
void sieve() {
  prime[0] = 1;
  prime[1] = 1;
  for (long long int i = 2; i <= 1000002; i++)
    prime[i] = i;
  for (long long int i = 2; i * i <= (1000002); i++) {
    if (prime[i] == i) {
      for (long long int j = i * i; j <= 1000002; j += i) {
        if (prime[j] == j)
          prime[j] = i;
      }
    }
  }
}

int count(int n) {
  unordered_map<int, int> m;
  while (n > 1) {
    m[prime[n]]++;
    n /= prime[n];
  }
  int ans = 1;
  for (auto k : m)
    ans *=
        (k.second +
         1); // using the divisor property (p+1)*(q+1) if num. n = (x^p)*(y^q)
  return ans;
}

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 solve(void) {
  int n;
  cin >> n;

  // sieve();
  LL total = 0;
  int numDiv;
  for (int c = 1; c < n; c++) {
    numDiv = countDivisors(n - c);
    total += numDiv;
  }
  cout << total << "\\n";
}

int main() {
  fastIO_test();

  LL t = 1;
  // cin >> t;
  while (t--) {
    solve();
  }
  return 0;
}

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

const int M = (int)1e9 + 7;
typedef long long LL;

void fastIO_test(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);

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

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 solve(void) {
  int n;
  cin >> n;

  // sieve();
  LL total = 0;
  LL x = n - 1;
  for (int c = 1; c < n; c++) {
    total += (x / c);
  }
  cout << total << "\\n";
}

int main() {
  fastIO_test();

  LL t = 1;
  // cin >> t;
  while (t--) {
    solve();
  }
  return 0;
}


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

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

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

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


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

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

  ll n, i, m, ans = 0, j;
  cin >> n;
  ll b, s;

  for (i = n - 1; i > 0; i--) {
    m = n - i;
    for (j = 1; j <= sqrt(m); j++) {
      if (m % j == 0) {
        b = m / j;
        s = b * j;

        if (j == b)
          ans++;
        if (j != b)
          ans += 2;
      }
    }
  }
  cout << ans << endl;
  return 0;
}

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

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

  ll i, j, tot = 0;
  for (i = 1; i < n; i++) {
    for (j = 1; j * i < n; j++)
      tot++;
  }
  cout << tot;
  return 0;
}


#ifndef DEBUG
#pragma GCC optimize("O3,no-stack-protector")
#pragma GCC optimize("unroll-loops")

#if __cplusplus < 201703L
#pragma GCC target("avx")
#else
#pragma GCC target("avx2")
#endif

#endif

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define dump(x) cout << x << endl
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i <= i##_len; ++i)
#define rep3(i, l, r) for (int i = l, i##_len = (r); i < i##_len; ++i)
#define REP3(i, l, r) for (int i = l, i##_len = (r); i <= i##_len; ++i)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
typedef int64_t Int;
typedef long double Ld;

using namespace std;
template <class T> using Graph = vector<vector<T>>;

const Ld pi = M_PI;
const Int MOD = 1000000007;
const Int INF = 1LL << 62;

Int Floor(Int a, Int b) { return (a - (a % b)) / b; }

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

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

template <typename T> inline T Gcd(T a, T b) {
  T c;
  while (b) {
    c = b;
    b = a % b;
    a = c;
  }
  return a;
}

Int Lcm(Int a, Int b) {
  if (a < b) {
    swap(a, b);
  }

  return a / Gcd(a, b) * b;
}

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

  return ret;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  Int n;
  cin >> n;

  Int ans = 1;
  for (Int i = 2; i < n; i++) {
    auto v = divisor(i);
    ans += v.size();
  }

  cout << ans << endl;

  return 0;
}

#ifndef DEBUG
#pragma GCC optimize("O3,no-stack-protector")
#pragma GCC optimize("unroll-loops")

#if __cplusplus < 201703L
#pragma GCC target("avx")
#else
#pragma GCC target("avx2")
#endif

#endif

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define dump(x) cout << x << endl
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i <= i##_len; ++i)
#define rep3(i, l, r) for (int i = l, i##_len = (r); i < i##_len; ++i)
#define REP3(i, l, r) for (int i = l, i##_len = (r); i <= i##_len; ++i)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
typedef int64_t Int;
typedef long double Ld;

using namespace std;
template <class T> using Graph = vector<vector<T>>;

const Ld pi = M_PI;
const Int MOD = 1000000007;
const Int INF = 1LL << 62;

Int Floor(Int a, Int b) { return (a - (a % b)) / b; }

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

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

template <typename T> inline T Gcd(T a, T b) {
  T c;
  while (b) {
    c = b;
    b = a % b;
    a = c;
  }
  return a;
}

Int Lcm(Int a, Int b) {
  if (a < b) {
    swap(a, b);
  }

  return a / Gcd(a, b) * b;
}

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

  return ret;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  Int n;
  cin >> n;

  vector<Int> d{
      93668,    201177,   313925,   430062,   548725,   669422,   791780,
      915548,   1040630,  1166750,  1293935,  1421996,  1550902,  1680578,
      1810953,  1942002,  2073666,  2205986,  2338763,  2472113,  2606008,
      2740315,  2875085,  3010305,  3145958,  3281973,  3418435,  3555195,
      3692338,  3829833,  3967622,  4105787,  4244274,  4382991,  4522065,
      4661460,  4801042,  4940922,  5081120,  5221472,  5362138,  5503108,
      5644159,  5785585,  5927210,  6069000,  6211021,  6353304,  6495814,
      6638449,  6781292,  6924353,  7067636,  7211106,  7354711,  7498504,
      7642514,  7786669,  7931004,  8075504,  8220199,  8364997,  8510049,
      8655190,  8800484,  8945974,  9091590,  9237328,  9383292,  9529316,
      9675504,  9821898,  9968324,  10114972, 10261748, 10408621, 10555635,
      10702823, 10850034, 10997454, 11145096, 11292653, 11440411, 11588376,
      11736313, 11884447, 12032740, 12181098, 12329547, 12478206, 12626845,
      12775675, 12924562, 13073587, 13222720, 13372007, 13521286, 13670825,
      13820360};
  Int ans = 0;
  if (1 <= (n - 1) / 10000) {
    ans = d[((n - 1) / 10000) - 1];
  }
  for (Int i = ((n - 1) / 10000) * 10000 + 1; i < n; i++) {
    ans += divisor(i).size();
  }

  cout << ans << endl;

  return 0;
}


#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#define ll long long int
#define ar array
#define ld long double
#define bigint int64_t
#define vll vector<ll>
#define pll ar<ll, 3>
#define vpll vector<pll>
#define pb push_back
#define MOD 1000000007
#define sz(x) (int)(x).size()
#define ff first
#define ss second
#define ok order_of_key
#define fo find_by_order
#define en cout << "\\n"
#define LCM(a, b) (a * (b / __gcd(a, b)))
#define all(v) v.begin(), v.end()
#define maxqueue priority_queue<int>
#define minqueue priority_queue<int, vector<int>, greater<int>>
#define lb(v, val) (lower_bound(v.begin(), v.end(), val) - v.begin())
#define ub(v, val) (upper_bound(v.begin(), v.end(), val) - v.begin())
#define INF (ll)1e18
#define NEGINF -INF
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define ini(a, b) memset(a, b, sizeof(a))
#define vvll vector<vector<ll>>
#define vt vector
#define fast                                                                   \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define MEM(a, b) memset(a, b, sizeof(a))
#define MAXN (int)(1 * 1e6 + 10)
#define prec(n) fixed << setprecision(n)
#define deb1(x) cerr << #x << ": " << x << endl
#define deb2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define deb3(x, y, z)                                                          \\
  cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": "    \\
       << z << endl
#define deb4(a, b, c, d)                                                       \\
  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << endl
#define deb5(a, b, c, d, e)                                                    \\
  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define deb6(a, b, c, d, e, f)                                                 \\
  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | "   \\
       << #f << ": " << f << endl
#define GET5(a, b, c, d, e, ...) e
#define D_EBC(...) GET5(__VA_ARGS__, deb4, deb3, deb2, deb1)
#define deb(...) D_EBC(__VA_ARGS__)(__VA_ARGS__)
#define each(x, a) for (auto &x : a)
#define F_OR(i, a, b, s)                                                       \\
  for (ll i = (a); ((s) > 0 ? i < (b) : i > (b)); i += (s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define forn(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)

using namespace std;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag,
// tree_order_statistics_node_update>; template <typename T> using mset =
// tree<T, null_type, less_equal<T>, rb_tree_tag,
// tree_order_statistics_node_update>; find_by_order(k) : iterator to value at
// kth index in sorted array. order_of_key(k) : Index of the value k

template <typename T> void read(T &x) { cin >> x; }
template <typename T, typename T0> void read(T &x, T0 &y) { cin >> x >> y; }

template <typename T, typename T0, typename T1> void read(T &x, T0 &y, T1 &z) {
  cin >> x >> y >> z;
}

template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
  cin >> x >> y >> z >> w;
}

template <typename T, typename T0> void read(pair<T, T0> &p) {
  cin >> p.fst >> p.scd;
}

template <typename T> void read(vector<T> &oneD) {
  for (ll i = 0; i < sz(oneD); i++) {
    read(oneD[i]);
  }
}

template <typename T> void read(T oneD[], ll n) {
  for (ll i = 0; i < n; i++) {
    read(oneD[i]);
  }
}

template <typename T> void write(T &x) { cout << x << " "; }

template <typename T, typename T0> void write(T &x, T0 &y) {
  cout << x << " " << y << "\\n";
}

template <typename T, typename T0, typename T1> void write(T &x, T0 &y, T1 &z) {
  cout << x << " " << y << " " << z << "\\n";
}

template <typename T, typename T0, typename T1, typename T2>
void write(T &x, T0 &y, T1 &z, T2 &w) {
  cout << x << " " << y << " " << z << " " << w << "\\n";
}

template <typename T, typename T0> void write(pair<T, T0> &p) {
  write(p.fst);
  write(p.scd);
  cout << endl;
}

template <typename T> void write(vector<T> &oneD) {
  for (ll i = 0; i < sz(oneD); i++) {
    write(oneD[i]);
  }
  cout << endl;
}

template <typename T> void write(T oneD[], int n) {
  for (ll i = 0; i < n; i++) {
    write(oneD[i]);
  }
  cout << endl;
}

template <typename T, typename T0> void write(map<T, T0> &mpp) {
  for (auto it : mpp) {
    write(it.fst);
    cout << ": ";
    write(it.scd);
    cout << "\\n";
  }
  cout << endl;
}
template <typename T> inline bool umax(T &x, T y) {
  return (y > x) ? x = y, true : false;
}
template <typename T> inline bool umin(T &x, T y) {
  return (y < x) ? x = y, true : false;
}

template <class T> void offset(ll o, T &x) { x += o; }
template <class T> void offset(ll o, vector<T> &x) { each(a, x) offset(o, a); }
template <class T, size_t S> void offset(ll o, ar<T, S> &x) {
  each(a, x) offset(o, a);
}

inline bool isSquare(ll x) {
  ll s = sqrt(x);
  return (s * s == x);
}
inline bool isPowerOfTwo(ll x) { return ((1LL << (ll)log2(x)) == x); }

ll extended_GCD(ll a, ll b, ll &x, ll &y) {
  if (a == 0) {
    x = 0;
    y = 1;
    return b;
  }
  ll x1, y1;
  ll gcd = extended_GCD(b % a, a, x1, y1);
  x = y1 - (b / a) * x1;
  y = x1;
  return gcd;
}

vector<ll> prime;

void sieve(ll N) {
  bool isPrime[N + !1];

  for (ll i = 0; i <= N; ++i) {
    isPrime[i] = true;
  }
  isPrime[0] = false;
  isPrime[1] = false;
  for (ll i = 2; i * i <= N; ++i) {
    if (isPrime[i] == true) {
      for (ll j = i * i; j <= N; j += i)
        isPrime[j] = false;
    }
  }

  for (ll i = 2; i <= N; i++) {
    if (isPrime[i] == true) {
      prime.push_back(i);
    }
  }
}

ll minPrime[MAXN];
void factorSieve(ll n) {
  memset(minPrime, 0, sizeof(minPrime));
  for (ll i = 2; i * i <= n; ++i) {
    if (minPrime[i] == 0) {
      for (ll j = i * i; j <= n; j += i) {
        if (minPrime[j] == 0) {
          minPrime[j] = i;
        }
      }
    }
  }
  for (ll i = 2; i <= n; ++i) {
    if (minPrime[i] == 0) {
      minPrime[i] = i;
    }
  }
}

ll factorize(ll n) {

  map<ll, ll> m;
  m.clear();
  while (n != 1) {
    m[minPrime[n]]++;
    n /= minPrime[n];
  }

  for (auto i : m) {
    if (i.second > 1) {
      return 0;
    }
  }

  return 1;
}

string to_string(char c) { return string(1, c); }

// bool safe(ll i, ll j) { return i >= 0 && i < n && j >= 0 && j < m; }

void solve() {
  ll n;
  read(n);
  ll ans = 0;
  forn(i, 1, n) {
    for (ll j = 1; j * j <= i; j++) {
      if (i % j == 0) {
        ans++;
        if (j != i / j) {
          ans++;
        }
      }
    }
  }
  cout << ans;
}

int main() {
  fast;
  int t = 1;
  // read(t);
  forn(t) {
    // cout << "Case #" << i+1 << ": ";
    solve();
  }
}

#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#define ll long long int
#define ar array
#define ld long double
#define bigint int64_t
#define vll vector<ll>
#define pll ar<ll, 3>
#define vpll vector<pll>
#define pb push_back
#define MOD 1000000007
#define sz(x) (int)(x).size()
#define ff first
#define ss second
#define ok order_of_key
#define fo find_by_order
#define en cout << "\\n"
#define LCM(a, b) (a * (b / __gcd(a, b)))
#define all(v) v.begin(), v.end()
#define maxqueue priority_queue<int>
#define minqueue priority_queue<int, vector<int>, greater<int>>
#define lb(v, val) (lower_bound(v.begin(), v.end(), val) - v.begin())
#define ub(v, val) (upper_bound(v.begin(), v.end(), val) - v.begin())
#define INF (ll)1e18
#define NEGINF -INF
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define ini(a, b) memset(a, b, sizeof(a))
#define vvll vector<vector<ll>>
#define vt vector
#define fast                                                                   \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define MEM(a, b) memset(a, b, sizeof(a))
#define MAXN (int)(1 * 1e6 + 10)
#define prec(n) fixed << setprecision(n)
#define deb1(x) cerr << #x << ": " << x << endl
#define deb2(x, y) cerr << #x << ": " << x << " | " << #y << ": " << y << endl
#define deb3(x, y, z)                                                          \\
  cerr << #x << ":" << x << " | " << #y << ": " << y << " | " << #z << ": "    \\
       << z << endl
#define deb4(a, b, c, d)                                                       \\
  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << endl
#define deb5(a, b, c, d, e)                                                    \\
  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define deb6(a, b, c, d, e, f)                                                 \\
  cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | "   \\
       << #f << ": " << f << endl
#define GET5(a, b, c, d, e, ...) e
#define D_EBC(...) GET5(__VA_ARGS__, deb4, deb3, deb2, deb1)
#define deb(...) D_EBC(__VA_ARGS__)(__VA_ARGS__)
#define each(x, a) for (auto &x : a)
#define F_OR(i, a, b, s)                                                       \\
  for (ll i = (a); ((s) > 0 ? i < (b) : i > (b)); i += (s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define forn(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)

using namespace std;

// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag,
// tree_order_statistics_node_update>; template <typename T> using mset =
// tree<T, null_type, less_equal<T>, rb_tree_tag,
// tree_order_statistics_node_update>; find_by_order(k) : iterator to value at
// kth index in sorted array. order_of_key(k) : Index of the value k

template <typename T> void read(T &x) { cin >> x; }
template <typename T, typename T0> void read(T &x, T0 &y) { cin >> x >> y; }

template <typename T, typename T0, typename T1> void read(T &x, T0 &y, T1 &z) {
  cin >> x >> y >> z;
}

template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
  cin >> x >> y >> z >> w;
}

template <typename T, typename T0> void read(pair<T, T0> &p) {
  cin >> p.fst >> p.scd;
}

template <typename T> void read(vector<T> &oneD) {
  for (ll i = 0; i < sz(oneD); i++) {
    read(oneD[i]);
  }
}

template <typename T> void read(T oneD[], ll n) {
  for (ll i = 0; i < n; i++) {
    read(oneD[i]);
  }
}

template <typename T> void write(T &x) { cout << x << " "; }

template <typename T, typename T0> void write(T &x, T0 &y) {
  cout << x << " " << y << "\\n";
}

template <typename T, typename T0, typename T1> void write(T &x, T0 &y, T1 &z) {
  cout << x << " " << y << " " << z << "\\n";
}

template <typename T, typename T0, typename T1, typename T2>
void write(T &x, T0 &y, T1 &z, T2 &w) {
  cout << x << " " << y << " " << z << " " << w << "\\n";
}

template <typename T, typename T0> void write(pair<T, T0> &p) {
  write(p.fst);
  write(p.scd);
  cout << endl;
}

template <typename T> void write(vector<T> &oneD) {
  for (ll i = 0; i < sz(oneD); i++) {
    write(oneD[i]);
  }
  cout << endl;
}

template <typename T> void write(T oneD[], int n) {
  for (ll i = 0; i < n; i++) {
    write(oneD[i]);
  }
  cout << endl;
}

template <typename T, typename T0> void write(map<T, T0> &mpp) {
  for (auto it : mpp) {
    write(it.fst);
    cout << ": ";
    write(it.scd);
    cout << "\\n";
  }
  cout << endl;
}
template <typename T> inline bool umax(T &x, T y) {
  return (y > x) ? x = y, true : false;
}
template <typename T> inline bool umin(T &x, T y) {
  return (y < x) ? x = y, true : false;
}

template <class T> void offset(ll o, T &x) { x += o; }
template <class T> void offset(ll o, vector<T> &x) { each(a, x) offset(o, a); }
template <class T, size_t S> void offset(ll o, ar<T, S> &x) {
  each(a, x) offset(o, a);
}

inline bool isSquare(ll x) {
  ll s = sqrt(x);
  return (s * s == x);
}
inline bool isPowerOfTwo(ll x) { return ((1LL << (ll)log2(x)) == x); }

ll extended_GCD(ll a, ll b, ll &x, ll &y) {
  if (a == 0) {
    x = 0;
    y = 1;
    return b;
  }
  ll x1, y1;
  ll gcd = extended_GCD(b % a, a, x1, y1);
  x = y1 - (b / a) * x1;
  y = x1;
  return gcd;
}

vector<ll> prime;

void sieve(ll N) {
  bool isPrime[N + !1];

  for (ll i = 0; i <= N; ++i) {
    isPrime[i] = true;
  }
  isPrime[0] = false;
  isPrime[1] = false;
  for (ll i = 2; i * i <= N; ++i) {
    if (isPrime[i] == true) {
      for (ll j = i * i; j <= N; j += i)
        isPrime[j] = false;
    }
  }

  for (ll i = 2; i <= N; i++) {
    if (isPrime[i] == true) {
      prime.push_back(i);
    }
  }
}

ll minPrime[MAXN];
void factorSieve(ll n) {
  memset(minPrime, 0, sizeof(minPrime));
  for (ll i = 2; i * i <= n; ++i) {
    if (minPrime[i] == 0) {
      for (ll j = i * i; j <= n; j += i) {
        if (minPrime[j] == 0) {
          minPrime[j] = i;
        }
      }
    }
  }
  for (ll i = 2; i <= n; ++i) {
    if (minPrime[i] == 0) {
      minPrime[i] = i;
    }
  }
}

ll factorize(ll n) {

  map<ll, ll> m;
  m.clear();
  while (n != 1) {
    m[minPrime[n]]++;
    n /= minPrime[n];
  }

  for (auto i : m) {
    if (i.second > 1) {
      return 0;
    }
  }

  return 1;
}

string to_string(char c) { return string(1, c); }

// bool safe(ll i, ll j) { return i >= 0 && i < n && j >= 0 && j < m; }

void solve() {
  ll n;
  read(n);
  factorSieve(1000001);
  ll ans = 0;
  forn(i, 1, n) {
    ll a = i, pr = 1, d = 0;
    ll pre = minPrime[a];
    while (minPrime[a] != 0 && a % minPrime[a] == 0) {
      if (minPrime[a] == pre) {
        d++;
      } else {
        pr *= (d + 1);
        d = 1;
        pre = minPrime[a];
      }
      a /= minPrime[a];
    }
    pr *= (d + 1);
    ans += pr;
  }
  cout << ans;
}

int main() {
  fast;
  int t = 1;
  // read(t);
  forn(t) {
    // cout << "Case #" << i+1 << ": ";
    solve();
  }
}


#include <bits/stdc++.h>
// #include <iostream>
// #include <utility>
// #include <string>
// #include <array>
using namespace std;

long long MOD = 1e9 + 7;
int MAX_INT = 1e9;

// 最大公約数
long long gcd(long long a, long long b) {
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
// 最小公倍数
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }

// x^y%p
long long modpow(long long x, long long y, long long p = 1) {
  long long res = 1;
  x = x % p;
  if (x == 0)
    return 0;
  while (y > 0) {
    if (y & 1)
      res = res * x % p;
    y = y >> 1;
    x = x * x % p;
  }
  return res;
}

int main(void) {
  ios::sync_with_stdio(false);
  cin.tie(NULL);

  long long N;
  cin >> N;

  long long cnt = 0;
  for (long long C = 1; C <= N; C++) {
    long long ans = N;
    ans -= C;
    for (long long A = 1; A <= N - C; A++) {
      if (ans % A == 0 && (N - C) / A != 0) {
        cnt++;
      }
    }
  }

  cout << cnt << endl;

  return 0;
}

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

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

  long long cnt = 0;
  for (long long A = 1; A < N; A++) {
    cnt += (N - 1) / A;
  }

  cout << cnt << endl;

  return 0;
}


#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
typedef long long ll;
using namespace std;

/*  divisor(n)
    入力：整数 n
    出力：nのすべての約数
    計算量：O(√n)
*/
vector<long long> divisor(long long n) {
  vector<long long> ret;
  for (long long i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(ret.begin(), ret.end()); // 昇順に並べる
  return ret;
}

void solve(long long N) {
  ll res = 0;
  for (int i = 1; i < N; i++) {
    vector<ll> div_num = divisor(i);
    res += div_num.size();
  }
  cout << res << endl;
}

// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
  long long N;
  scanf("%lld", &N);
  solve(N);
  return 0;
}

#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
typedef long long ll;
using namespace std;

/*  divisor(n)
    入力：整数 n
    出力：nのすべての約数
    計算量：O(√n)
*/
vector<long long> divisor(long long n) {
  vector<long long> ret;
  for (long long i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  // sort(ret.begin(), ret.end()); // 昇順に並べる
  return ret;
}

void solve(long long N) {
  ll res = 0;
  for (int i = 1; i <= N; i++) {
    res += (N - 1) / i;
  }
  cout << res << endl;
}

// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools  (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
  long long N;
  scanf("%lld", &N);
  solve(N);
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const double PI = 4 * atan(1);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-9;
const string YES = "Possible";
const string NO = "Impossible";
#define pb push_back
#define mp make_pair
#define eb emplace_back

const int MAX_N = 2e6 + 10;
int N;

int cal(int x) {
  int res = 0;
  bool f = false;
  for (int i = 1; i * i <= x; ++i) {
    if (x % i == 0) {
      res += 2;
    }
    if (i * i == x) {

      f = true;
    }
  }
  if (f)
    res--;
  return res;
}

void solve() {
  ll res = 0;
  for (int c = 1; c < N; ++c) {
    res += cal(N - c);
  }
  cout << res << '\\n';
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> N;
  solve();
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const double PI = 4 * atan(1);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-9;
const string YES = "Possible";
const string NO = "Impossible";
#define pb push_back
#define mp make_pair
#define eb emplace_back

const int MAX_N = 1e6 + 10;
int N;
ll num[MAX_N];

void cal(int x) {
  int res = 0;
  bool f = false;
  for (int i = 1; i * i <= x; ++i) {
    if (x % i == 0) {
      res += 2;
    }
    if (i * i == x) {
      f = true;
    }
  }
  if (f)
    res--;
  num[x] = res;
}

void solve() {
  for (int i = 1; i <= N; ++i)
    cal(i);
  ll res = 0;
  for (int c = 1; c < N; ++c) {
    res += num[N - c];
  }
  cout << res << '\\n';
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> N;
  solve();
  return 0;
}