#include <bits/stdc++.h>
using namespace std;
signed main(void) {
  int n;
  long long ans = 0;
  cin >> n;
  for (int i = 1; i < n; i++) {
    int ab = n - i;
    for (int j = 1; j <= int(sqrt(ab)); j++) {
      if (j == sqrt(ab) && ab % j == 0)
        ans++;
      else if (ab % j == 0)
        ans += 2;
    }
  }
  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
inline int read(int x) {
  int f = 1, n = 0;
  char c = getchar();
  while (!isdigit(c)) {
    if (c == '-')
      f = 0;
    c = getchar();
  }
  while (isdigit(c)) {
    n = n * 10 + int(c - '0');
    c = getchar();
  }
  return f * n;
}
signed main(void) {
  int n, ans = 0;
  n = read(n);
  for (int i = 1; i < n; ++i) {
    int ab = n - i;
    for (int j = 1; j <= int(sqrt(ab)); ++j) {
      if (ab % j == 0) {
        if (j == sqrt(ab))
          ++ans;
        else
          ans += 2;
      }
    }
  }
  printf("%d\\n", ans);
  return 0;
}


#include <bits/stdc++.h>
#include <functional>
using namespace std;
typedef pair<int, int> pii;
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
#define ll long long
#define ld long double
#define rep(i, a) for (ll i = 0; i < a; i++)
#define repe(i, a, b) for (ll i = a; i < b; i++)
#define bac(i, a) for (ll i = a; i >= 0; i--)
#define bace(i, a, b) for (ll i = a; i >= b; i--)
#define pb push_back
#define in insert
#define ff first
#define ss second
#define setbit(x) __builtin_popcountll(x)
#define init(c, a) memset(c, a, sizeof(c))
#define all(c) c.begin(), c.end()
#define sz(c) (ll) c.size()
#define lb lower_bound
#define ub upper_bound
#define maxe *max_element
#define mine *min_element
#define rev reverse
#define Y "YES"
#define N "NO"
#define endl "\\n"
#define debug(x) cout << #x << " : " << x << endl;
const ll inf = 1e18;
const ll mod = 1e9 + 7;
const ll MOD = 998244353;
const ll MAX = 2e5 + 1;
// priority_queue<pii, vector<pii>, greater<pii> > pq;

inline ll add(ll a, ll b) { return ((a % mod) + (b % mod)) % mod; }
inline ll sub(ll a, ll b) { return ((a % mod) - (b % mod) + mod) % mod; }
inline ll mul(ll a, ll b) { return ((a % mod) * (b % mod)) % mod; }
ll pwr(ll x, ll n) {
  if (n == 0) {
    return 1;
  }
  if (n & 1) {
    return mul(x, pwr(mul(x, x), (n - 1) / 2));
  } else {
    return pwr(mul(x, x), n / 2);
  }
}
ll modInv(ll n) { return pwr(n, mod - 2); }
ll gcd(ll a, ll b) {
  if (b == 0) {
    return a;
  }
  return gcd(b, a % b);
}

/**

 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 right(right) {}
 * };
 */

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

#include <bits/stdc++.h>
#include <functional>
using namespace std;
typedef pair<int, int> pii;
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
#define ll long long
#define ld long double
#define rep(i, a) for (ll i = 0; i < a; i++)
#define repe(i, a, b) for (ll i = a; i < b; i++)
#define bac(i, a) for (ll i = a; i >= 0; i--)
#define bace(i, a, b) for (ll i = a; i >= b; i--)
#define pb push_back
#define in insert
#define ff first
#define ss second
#define setbit(x) __builtin_popcountll(x)
#define init(c, a) memset(c, a, sizeof(c))
#define all(c) c.begin(), c.end()
#define sz(c) (ll) c.size()
#define lb lower_bound
#define ub upper_bound
#define maxe *max_element
#define mine *min_element
#define rev reverse
#define Y "YES"
#define N "NO"
#define endl "\\n"
#define debug(x) cout << #x << " : " << x << endl;
const ll inf = 1e18;
const ll mod = 1e9 + 7;
const ll MOD = 998244353;
const ll MAX = 2e5 + 1;
// priority_queue<pii, vector<pii>, greater<pii> > pq;

inline ll add(ll a, ll b) { return ((a % mod) + (b % mod)) % mod; }
inline ll sub(ll a, ll b) { return ((a % mod) - (b % mod) + mod) % mod; }
inline ll mul(ll a, ll b) { return ((a % mod) * (b % mod)) % mod; }
ll pwr(ll x, ll n) {
  if (n == 0) {
    return 1;
  }
  if (n & 1) {
    return mul(x, pwr(mul(x, x), (n - 1) / 2));
  } else {
    return pwr(mul(x, x), n / 2);
  }
}
ll modInv(ll n) { return pwr(n, mod - 2); }
ll gcd(ll a, ll b) {
  if (b == 0) {
    return a;
  }
  return gcd(b, a % b);
}

/**

 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
 right(right) {}
 * };
 */

int main() {
  int n;
  cin >> n;
  ll ans = 0;
  ll cnt = 0;
  n--;
  for (int j = 1; j <= n; ++j) {
    ans += n / j;
  }

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


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

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

  vector<int> primeVec = {2};

  long long setsCount = 1;

  for (int a = 2; a <= n - 1; ++a) {
    int divisorCount = 1;
    int aRem = a;

    for (int index = 0; index < primeVec.size(); ++index) {
      int primeI = primeVec.at(index);

      int count = 0;

      while (aRem % primeI == 0) {
        aRem /= primeI;
        ++count;
      }

      divisorCount *= (count + 1);

      if (aRem == 1) {
        break;
      }
    }

    if (divisorCount == 1) {
      primeVec.push_back(a);

      ++divisorCount;
    }

    setsCount += divisorCount;
  }

  cout << setsCount << endl;
}

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

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

  int cnt = 0;

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

  cout << cnt << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

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);
    }
  }
  return (ll)(ret.size());
}

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

  for (ll c = 1; c <= n - 1; c++) {
    ans += divisor(n - c);
  }

  cout << ans << "\\n";

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 998244353;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

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

  ll ans = 0;

  for (ll a = 1; a <= n; a++) {
    if ((n / a) * a != n)
      ans += n / a;
    else
      ans += (n / a - 1);
  }

  cout << ans << "\\n";

  return 0;
}


#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define faster                                                                 \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define pii pair<int, int>
#define mp make_pair
#define pb push_back
#define show(v)                                                                \\
  for (int i : v)                                                              \\
    cout << i << " ";                                                          \\
  cout << endl;
#define sall(v) sort(v.begin(), v.end());

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int inf = 1e9;
int mod = 1e9 + 7;
const int MAXN = 100005;

// vector<int> g[MAXN];
// vector<bool> was;
// vector<int> d, a;
// int n, m, k, c;
//
// void dfs(int v) {
//     was[v] = true;
//     d[v] = c;
//     for(int to : g[v]){
//         if(!was[to]){
//             dfs(to);
//         }
//     }
// }
//
//
// void solve() {
//     cin >> n >> m >> k;
//     c = 0;
//     d.assign(n, 0);
//     a.assign(k, 0);
//     was.assign(n, false);
//     for(int i = 0;i < k;i++){
//         cin >> a[i];
//         a[i]--;
//     }
//     for(int i = 0;i < n;i++){
//         int x, y;
//         cin >> x >> y;
//         g[x].pb(y);
//         g[y].pb(y);
//     }
//     for(int i = 0;i < n;i++){
//         if(!was[i]){
//             dfs(i);
//             c++;
//         }
//     }
//
// }

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

#include <algorithm>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define faster                                                                 \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define pii pair<int, int>
#define mp make_pair
#define pb push_back
#define show(v)                                                                \\
  for (int i : v)                                                              \\
    cout << i << " ";                                                          \\
  cout << endl;
#define sall(v) sort(v.begin(), v.end());

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int inf = 1e9;
int mod = 1e9 + 7;
const int MAXN = 1000005;
int a[MAXN];

// vector<int> g[MAXN];
// vector<bool> was;
// vector<int> d, a;
// int n, m, k, c;
//
// void dfs(int v) {
//     was[v] = true;
//     d[v] = c;
//     for(int to : g[v]){
//         if(!was[to]){
//             dfs(to);
//         }
//     }
// }
//
//
// void solve() {
//     cin >> n >> m >> k;
//     c = 0;
//     d.assign(n, 0);
//     a.assign(k, 0);
//     was.assign(n, false);
//     for(int i = 0;i < k;i++){
//         cin >> a[i];
//         a[i]--;
//     }
//     for(int i = 0;i < n;i++){
//         int x, y;
//         cin >> x >> y;
//         g[x].pb(y);
//         g[y].pb(y);
//     }
//     for(int i = 0;i < n;i++){
//         if(!was[i]){
//             dfs(i);
//             c++;
//         }
//     }
//
// }

int main() {
  faster for (int i = 1; i < MAXN; i++) {
    for (int j = 1; j < MAXN; j++) {
      if (i * j >= MAXN)
        break;
      a[i * j]++;
    }
  }
  int n;
  cin >> n;
  int cnt = 0;
  for (int i = 1; i <= n; i++) {
    int s = n - i;
    cnt += a[s];
  }
  cout << cnt << endl;
  return 0;
}


/* https://codeforces.com/contest/1360/problem/H */
#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using vs = vector<string>;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vpi = vector<pair<int, int>>;
using vpl = vector<pair<ll, ll>>;
using ld = double;

#define f first
#define s second
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define ins insert

const int MAX = INT_MAX;
const int MOD = 998244353;

int main() {
  int N;
  cin >> N;
  int ans = 0;
  for (int i = 1; i <= N; ++i)
    for (int j = 1; j <= N; ++j)
      for (int k = 1; k <= N; ++k)
        if (j * i + k == N)
          ans++;

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

/* https://codeforces.com/contest/1360/problem/H */
#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using vs = vector<string>;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vpi = vector<pair<int, int>>;
using vpl = vector<pair<ll, ll>>;
using ld = double;

#define f first
#define s second
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)(x).size()
#define all(x) x.begin(), x.end()
#define ins insert

const int MAX = INT_MAX;
const int MOD = 998244353;

int main() {
  int N;
  cin >> N;
  int ans = 0;
  for (int i = 1; i < N; ++i)
    for (int j = 1; i * j < N; ++j)
      ans++;

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


/*******************************
 * BASMILLAHHIR RAHMANNIR RAHIM *
 * MD SHAHINUR RAHMAN           *
 * DATE: 16/sep/2020            *
 * DEPT. OF CSE                 *
 * LEADING UNIVERSITY, SYLHET   *
 *******************************/
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define shahin                                                                 \\
  std::ios_base::sync_with_stdio(false);                                       \\
  std::cin.tie(NULL);
#define ll long long
#define pb push_back
#define sz(x) (int)(x).size()
const int nax = 1000 * 1007;
const int mod = 1e9 + 7;

using namespace std;
char wcz[nax];

bool fu(int a, int b) { return (a > b); }
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }

void fun() {
  ll n, s = 0;
  cin >> n;
  for (int i = 1; i <= n; i++) {
    for (int j = 1; j < n; j++) {
      for (int k = 1; k < n; k++) {
        if (i * j + k == n)
          s++;
      }
    }
  }
  cout << s << endl;
}
int main() {
  shahin
  /*   int tc,i=1,sum=0,A=0,B=0;
     cin >> tc;
     while(tc--)
     {
     //cout << "Case " << i << ": ";
         fun();
     //i++;
     }*/
  fun();
}

/*******************************
 * BASMILLAHHIR RAHMANNIR RAHIM *
 * MD SHAHINUR RAHMAN           *
 * DATE: 16/sep/2020            *
 * DEPT. OF CSE                 *
 * LEADING UNIVERSITY, SYLHET   *
 *******************************/
#include <algorithm>
#include <bits/stdc++.h>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define shahin                                                                 \\
  std::ios_base::sync_with_stdio(false);                                       \\
  std::cin.tie(NULL);
#define ll long long
#define pb push_back
#define sz(x) (int)(x).size()
const int nax = 1000 * 1007;
const int mod = 1e9 + 7;

using namespace std;
char wcz[nax];

bool fu(int a, int b) { return (a > b); }
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }

void fun() {
  ll n, s = 0;
  cin >> n;

  for (int i = 1; i <= n; i++) {
    ll a = (n - 1) / i;
    s += a;
  }

  cout << s << endl;
}
int main() {
  shahin
  /*   int tc,i=1,sum=0,A=0,B=0;
     cin >> tc;
     while(tc--)
     {
     //cout << "Case " << i << ": ";
         fun();
     //i++;
     }*/
  fun();
}


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

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

  for (int c = 1; c < n; c++) {
    int tmp = 0;
    for (int a = 1; a * a <= n - c; a++) {
      if ((n - c) % a == 0) {
        int b = (n - c) / a;
        if (a == b)
          ans++;
        else
          ans += 2;
      }
    }
  }

  cout << ans << endl;
}

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

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

  for (int a = 1; a <= n - 1; a++) {
    ans += (n - 1) / a;
  }
  cout << ans << endl;
}


#include <stdio.h>
#include <string.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define rep(i, N) for (int i = 0; i < (int)N; i++)
static inline void PUT(char c) {
  static char buf[1 << 15], *ptr = buf;
  if (ptr == buf + strlen(buf) || c == 0) {
    fwrite(buf, 1, ptr - buf, stdout), ptr = buf;
  }
  *ptr++ = c;
}
static inline int IN(void) {
  int x = 0, f = 0, c = getchar();
  while (c < 48 || c > 57) {
    f ^= c == 45, c = getchar();
  }
  while (c > 47 && c < 58) {
    x = x * 10 + c - 48, c = getchar();
  }
  return f ? -x : x;
}
static inline void OUT(int a) {
  if (a < 0)
    PUT('-'), a = -a;
  int d[40], i = 0;
  do {
    d[i++] = a % 10;
  } while (a /= 10);
  while (i--) {
    PUT(d[i] + 48);
  }
  PUT('\\n');
}
int main() {
  int N = IN(), count = 0;
  rep(i, N) rep(j, N) rep(k, N) {
    if ((i + 1) * (j + 1) + k + 1 == N) {
      count++;
    }
  }
  return OUT(count), 0;
}

#include <stdio.h>
#include <string.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define rep(i, N) for (int i = 0; i < (int)N; i++)
static inline void PUT(char c) {
  static char buf[1 << 15], *ptr = buf;
  if (ptr == buf + strlen(buf) || c == 0) {
    fwrite(buf, 1, ptr - buf, stdout), ptr = buf;
  }
  *ptr++ = c;
}
static inline int IN(void) {
  int x = 0, f = 0, c = getchar();
  while (c < 48 || c > 57) {
    f ^= c == 45, c = getchar();
  }
  while (c > 47 && c < 58) {
    x = x * 10 + c - 48, c = getchar();
  }
  return f ? -x : x;
}
static inline void OUT(int a) {
  if (a < 0)
    PUT('-'), a = -a;
  int d[40], i = 0;
  do {
    d[i++] = a % 10;
  } while (a /= 10);
  while (i--) {
    PUT(d[i] + 48);
  }
  PUT('\\n');
}
int main() {
  int N = IN(), count = 0;
  rep(i, N - 1) { count += (N - 1) / (i + 1); }
  return OUT(count), 0;
}


#include <bits/stdc++.h>

using namespace std;

#define pb push_back
#define ll long long
#define speed ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define bug cout << "ok" << endl

const ll INF = 1e9 + 5, N = 1e6 + 5, mod = 998244353, M = 1e6 + 5;

int main() {
  int d[N];
  ll n;
  cin >> n;
  ll ans = 1;
  for (int i = 2; i < n; i++) {
    for (int j = 1; j <= sqrt(i); j++) {
      if (i % j == 0) {
        int dv = i / j;
        if (i / dv == dv)
          ans--;
        ans += 2;
      }
    }
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>

using namespace std;

#define pb push_back
#define ll long long
#define speed ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define bug cout << "ok" << endl

const ll INF = 1e9 + 5, N = 1e6 + 5, mod = 998244353, M = 1e6 + 5;

ll d[N];

int main() {
  for (ll i = 2; i <= N - 5; i++) {
    if (d[i] > 0)
      continue;
    d[i] = i;
    ll ch = i * 1ll * i;
    if (ch > N - 5)
      continue;
    for (ll j = i * i; j <= N - 5; j += i) {
      if (d[j] > 0)
        continue;
      d[j] = i;
    }
  }
  ll n;
  cin >> n;
  ll ans = 1;
  for (int i = 2; i < n; i++) {
    ll cnt = 1;
    ll x = i;
    while (x > 1) {
      int dv = d[x];
      int um = 1;
      while (x % dv == 0) {
        um++;
        x /= dv;
      }
      cnt *= um;
    }
    ans += (cnt);
  }
  cout << ans << endl;
}


#include <bits/stdc++.h>
#include <iostream>
#define LL long long int
using namespace std;
LL div(LL n) {
  LL count = 0;
  for (LL i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      count++;
      if (n / i != i)
        count++;
    }
  }
  return count;
}
int main() {
  //	ios_base::sync_with_stdio(false);
  //  cin.tie(NULL);
  vector<LL> v;
  v.push_back(0);
  for (LL i = 1; i <= 1000000; i++) {
    LL c = div(i - 1);
    v.push_back(v[i - 1] + c);
  }
  LL n;
  cin >> n;
  cout << v[n] << "\\n";
}

#include <bits/stdc++.h>
#include <iostream>
#define LL long long int
using namespace std;
LL div(LL n) {
  LL count = 0;
  for (LL i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      count++;
      if (n / i != i)
        count++;
    }
  }
  return count;
}
int main() {
  //	ios_base::sync_with_stdio(false);
  //  cin.tie(NULL);
  vector<LL> v;
  v.push_back(0);
  LL n;
  cin >> n;
  LL count = 0;
  n--;
  LL r = sqrt(n);
  for (LL i = 1; i <= r; i++) {
    count += n / i;
  }
  count = count * 2;
  count -= r * r;
  cout << count << "\\n";
}


#include <iostream>
using namespace std;

int isqrt(int n) {
  int i = 1;
  while (i * i < n) {
    i <<= 1;
  }
  int res = 0;
  while (i > 0) {
    if ((res + i) * (res + i) <= n) {
      res += i;
    }
    i >>= 1;
  }
  return res;
}

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

  int N;
  cin >> N;
  int cnt = 0;
  for (int c = 1; c < N; c++) {
    int ab = N - c;
    for (int a = 1; a <= isqrt(ab); a++) {
      if (ab % a == 0) {
        if (a * a == ab) {
          cnt++;
        } else {
          cnt += 2;
        }
      }
    }
  }
  cout << cnt << "\\n";
  return 0;
}

#include <iostream>
using namespace std;

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

  int N;
  cin >> N;
  int cnt = 0;
  for (int a = 1; a < N; a++) {
    cnt += (N - 1) / a;
  }
  cout << cnt << "\\n";
  return 0;
}


#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main() {
#ifdef LOCAL_EXEC
#else
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
#endif // LOCAL_EXEC
  int n, i, j, k, x, y, z;
  cin >> n;
  int dp[n + 1];
  dp[0] = 0;
  dp[1] = 0;
  for (i = 2; i <= n; i++) {
    dp[i] = dp[i - 1];
    x = 0;
    for (j = 1; j * j <= i - 1; j++) {
      if ((i - 1) % j == 0) {
        x += 1;
        if (j != (i - 1) / j)
          x += 1;
      }
    }
    dp[i] += x;
  }
  cout << dp[n];
  return 0;
}

#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main() {
#ifdef LOCAL_EXEC
#else
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
#endif // LOCAL_EXEC
  long long int n, i, j, k, x = 0, y;
  cin >> n;
  for (i = 1; i <= n - 1; i++) {
    x += (n - 1) / i;
  }
  cout << x;
  return 0;
}


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

#define print cout <<
#define printl(s) cout << s << endl;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;

const ll modseed = pow(10, 9) + 7;

template <typename T> vector<T> getValues(int num) {
  vector<T> values(num);
  for (int i = 0; i < num; i++) {
    cin >> values.at(i);
  }
  return values;
}

int main() {
  int N;
  cin >> N;
  int ans = 0;
  for (int c = 1; c < N; c++) {
    ll tg = N - c;
    for (ll a = 1; a * a <= tg; a++) {
      if (tg % a != 0) {
        continue;
      }
      ans++;
      if (tg != a * a) {
        ans++;
      }
    }
  }
  printl(ans);
}

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

#define print cout <<
#define printl(s) cout << s << endl;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;

const ll modseed = pow(10, 9) + 7;

template <typename T> vector<T> getValues(int num) {
  vector<T> values(num);
  for (int i = 0; i < num; i++) {
    cin >> values.at(i);
  }
  return values;
}

int main() {
  int N;
  cin >> N;
  int ans = 0;
  for (int a = 1; a < N; a++) {
    for (int b = 1; b < N; b++) {
      if (a * b >= N) {
        break;
      }
      ans++;
    }
  }
  printl(ans);
}


#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
  long long n, i, p, j, s, k, total = 0;
  cin >> n;
  for (i = 1; i <= n - 1; i++) {
    p = n - i;
    s = 0;
    for (j = 1; j <= sqrt(p); j++) {
      if (p % j == 0) {
        s++;
      }
    }
    total += (2 * s);
    k = sqrt(p);
    if ((k * k) == p) {
      total--;
    }
  }
  cout << total << endl;
  return 0;
}

#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
  long long n, i, p, j, s, k, total = 0;
  cin >> n;
  for (i = 1; i <= (n - 1); i++) {
    for (j = 1; j <= (n - 1); j++) {
      if ((i * j) < n) {
        total++;
      } else {
        break;
      }
    }
  }
  cout << total << endl;
  return 0;
}


#include <bits/stdc++.h>

//{ START
using namespace std;
#define int int64_t
#define rep(i, a, n) for (int i = (a); i < (n); ++i)
#define reps(i, a, n) for (int i = (n - 1); i > (a - 1); --i)
#define arep(i, x) for (auto &&i : (x))
#define irep(i, x) for (auto i = (x).begin(); i != (x).end(); ++i)
#define rirep(i, x) for (auto i = (x).rbegin(); i != (x).rend(); ++i)
// 降順はgreater<T>()
#define all(x) (x).begin(), (x).end()
#define rv(s) reverse((s).begin(), (s).end())
// gcd lcmはそのままok
#define gcd(a, b) __gcd(a, b)
#define bits(n) (1LL << (n))
#define pcnt(x) __builtin_popcountll(x)
// 配列内等要素削除
#define Unique(x) (x).erase(unique((x).begin(), (x).end()), (x).end())
#define Fixed(n) fixed << setprecision(n)
// 総和
#define sowa(n) (((n) * ((n) + 1)) / 2)
#define updiv(a, b) ((a + b - 1) / b)
#define cauto const auto &
using P = pair<int, int>;
using Graph = vector<vector<P>>;
template <class T> // 昇順
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T> // 降順
using max_heap = priority_queue<T>;
template <class A, class B> using umap = unordered_map<A, B>;
template <class A> using uset = unordered_set<A>;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) { // 多次元初期化
  std::fill((T *)array, (T *)(array + N), val);
}
template <class A, class B>
bool chmax(A &a, const B &b) { // 最大値更新 返り値はbool
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class A, class B>
bool chmin(A &a, const B &b) { // 最小値更新 返り値はbool
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, 1, 1, -1, -1};
constexpr int INF = 0x3f3f3f3f;
constexpr int LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int mod1 = 1e9 + 7;
constexpr int mod2 = 998244353;
//} END

// 約数列挙 o(√n)
vector<int> divisor(int n) {
  vector<int> res;
  for (int i = 1; i * i <= n; ++i) {
    if (n % i == 0) {
      res.push_back(i);
      if (i != n / i)
        res.push_back(n / i);
    }
  }
  return res;
}

// エラトトステネスの篩を用いた高速な素因数分解
vector<int> sieve_prime_factor(size_t max) {
  vector<bool> IsPrime(max + 1, true);
  vector<int> prime(max + 1), spf(max + 1);
  IsPrime[0] = IsPrime[1] = false; // 0,1の初期化
  for (size_t i = 2; i <= max; ++i) {
    if (IsPrime[i] == true)
      for (size_t j = i; j <= max; j += i) {
        IsPrime[j] = false; // 非素数を記録
        prime[j] = i;       // 非素数を保存
      }
  }
  // prime[i]を用いて各iの素因数を列挙可能
  for (size_t i = 1; i <= max; ++i) {
    int now = i;
    while (now != 1) {
      spf[prime[now]]++;
      now /= prime[now];
    }
  }
  return spf;
}

signed main(void) {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);

  int n;
  cin >> n;
  // int spf = sieve_prime_factor(n+1);
  int cnt = 0;
  if (n == 2) {
    cout << 1 << '\\n';
    return 0;
  }
  rep(i, 1, n) {
    auto now = divisor(n - i);
    cnt += now.size();
    // cout << now.size() << ' ';
    // cout << cnt << '\\n';
  }
  cout << cnt << '\\n';
  return 0;
}

#include <bits/stdc++.h>

//{ START
using namespace std;
#define int int64_t
#define rep(i, a, n) for (int i = (a); i < (n); ++i)
#define reps(i, a, n) for (int i = (n - 1); i > (a - 1); --i)
#define arep(i, x) for (auto &&i : (x))
#define irep(i, x) for (auto i = (x).begin(); i != (x).end(); ++i)
#define rirep(i, x) for (auto i = (x).rbegin(); i != (x).rend(); ++i)
// 降順はgreater<T>()
#define all(x) (x).begin(), (x).end()
#define rv(s) reverse((s).begin(), (s).end())
// gcd lcmはそのままok
#define gcd(a, b) __gcd(a, b)
#define bits(n) (1LL << (n))
#define pcnt(x) __builtin_popcountll(x)
// 配列内等要素削除
#define Unique(x) (x).erase(unique((x).begin(), (x).end()), (x).end())
#define Fixed(n) fixed << setprecision(n)
// 総和
#define sowa(n) (((n) * ((n) + 1)) / 2)
#define updiv(a, b) ((a + b - 1) / b)
#define cauto const auto &
using P = pair<int, int>;
using Graph = vector<vector<P>>;
template <class T> // 昇順
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T> // 降順
using max_heap = priority_queue<T>;
template <class A, class B> using umap = unordered_map<A, B>;
template <class A> using uset = unordered_set<A>;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) { // 多次元初期化
  std::fill((T *)array, (T *)(array + N), val);
}
template <class A, class B>
bool chmax(A &a, const B &b) { // 最大値更新 返り値はbool
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class A, class B>
bool chmin(A &a, const B &b) { // 最小値更新 返り値はbool
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, 1, 1, -1, -1};
constexpr int INF = 0x3f3f3f3f;
constexpr int LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int mod1 = 1e9 + 7;
constexpr int mod2 = 998244353;
//} END

// 約数列挙 o(√n)
vector<int> divisor(int n) {
  vector<int> res;
  for (int i = 1; i * i <= n; ++i) {
    if (n % i == 0) {
      res.push_back(i);
      if (i != n / i)
        res.push_back(n / i);
    }
  }
  return res;
}

// エラトトステネスの篩を用いた高速な素因数分解
vector<int> sieve_prime_factor(size_t max) {
  vector<bool> IsPrime(max + 1, true);
  vector<int> prime(max + 1), spf(max + 1);
  IsPrime[0] = IsPrime[1] = false; // 0,1の初期化
  for (size_t i = 2; i <= max; ++i) {
    if (IsPrime[i] == true)
      for (size_t j = i; j <= max; j += i) {
        IsPrime[j] = false; // 非素数を記録
        prime[j] = i;       // 非素数を保存
      }
  }
  // prime[i]を用いて各iの素因数を列挙可能
  for (size_t i = 1; i <= max; ++i) {
    int now = i;
    while (now != 1) {
      spf[prime[now]]++;
      now /= prime[now];
    }
  }
  return spf;
}

signed main(void) {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);

  int n;
  cin >> n;
  // int spf = sieve_prime_factor(n+1);
  int cnt = 0;
  rep(i, 1, n + 1) {
    rep(j, 1, n + 1) {
      if (i * j >= n)
        break;
      else
        ++cnt;
    }
  }
  cout << cnt << '\\n';
  return 0;
}


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

int main(void) {
  int n, a, b, cnt = 0, eq_cnt = 0;
  cin >> n;

  for (a = 1; a <= n - 1; a++) {
    for (b = 1; b <= a; b++) {
      if (a * b < n) {
        cnt++;
        if (a == b) {
          eq_cnt++;
        }
      }
    }
  }
  cnt = cnt * 2 - eq_cnt;

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

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

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

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

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


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

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

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

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


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

unsigned long long getResult(const uint n) {
  uint a, b, c;
  unsigned long long pattern = 0;
  for (c = 1; c < n; c++) {
    uint ab = n - c;
    for (b = 1;; b++) {
      a = ab / b;
      if (a < b) {
        break;
      }
      if (ab % b == 0) {
        pattern += (a == b) ? 1 : 2;
      }
    }
  }
  return pattern;
}

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

  unsigned long long result = getResult(N);
  cout << result;
  return 0;
}

#include <iostream>
using namespace std;

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

  unsigned long long result = 0;
  for (uint a = 1; a < N; a++) {
    uint b = (N - 1) / a;
    result += b;
  }
  cout << result;
  return 0;
}


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

int main() {
  int n;
  cin >> n;
  int count = 0;
  for (int i = 1; i < n; i++) {
    for (int j = 1; j < n; j++) {
      for (int k = 1; k < n; k++) {
        if (i * j + k == n) {
          count++;
        }
      }
    }
  }
  cout << count;
  return 0;
}

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

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


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

int main() {
  int n;
  cin >> n;
  int cnt = 0;
  REP(c, n + 1) {
    double sqr = sqrt(c);
    if (floor(sqrt(c)) == sqrt(c))
      cnt++;
    REP(a, sqr) {
      if ((n - c) % a == 0) {
        int b = (n - c) / a;
        if (b != 0)
          cnt += 2;
      }
    }
  }
  if (floor(sqrt(n)) == sqrt(n))
    cnt--;
  cout << cnt << '\\n';
  return 0;
}

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

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

int main() {
  int n;
  cin >> n;
  ll cnt = 0;
  REP(c, n) {
    const auto &pf = prime_factorize(n - c);
    ll res = 1;
    for (auto p : pf)
      res *= p.second + 1;
    cnt += res;
  }
  cout << cnt << '\\n';
  return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>

#include <bits/stdc++.h>
#include <cmath>
#include <limits>

using namespace std;
typedef long long LL;
using Graph = vector<vector<int>>;

static long long INF = (1LL << 62);

int isPrime(LL p) {
  if (p <= 1)
    return 0;
  if (p == 2 || p == 3 || p == 5 || p == 7)
    return 1;
  if (p == 4 || p == 6 || p == 8 || p == 9)
    return 0;

  LL i;
  int ret = 1;
  for (i = 2; i * i <= p; i++) {
    if (p % i == 0 && i != p) {
      ret = 0;
      break;
    }
  }
  return ret;
}

void factorize(long long N, map<long long, int> &mp) {
  if (N == 1) {
    return;
  }
  if (isPrime(N)) {
    mp[N] += 1;
    return;
  }

  long long i = 2, n = N;
  for (i = 2; n != 1 && i < (N / 2) + 1; i++) {
    if ((n % i) == 0) {
      if (isPrime(i)) {
        int e = 0;
        long long u = n;
        while ((u % i) == 0) {
          e++;
          u = u / i;
          n = u;
        }
        mp[i] = e;
        if (isPrime(n)) {
          mp[n] = 1;
          break;
        }
      }
    }
  }
  return;
}

LL calcd(map<LL, int> &mp) {
  LL ret = 1;
  for (auto itr = mp.begin(); itr != mp.end(); itr++) {
    int v = itr->second;
    ret *= (v + 1);
  }
  return ret;
}

int main(int argc, char *argv[]) {
  cin.tie(0);
  ios::sync_with_stdio(false);

  LL N;
  cin >> N;
  LL ans = 0;
  for (LL i = 1; i < N; i++) {
    map<LL, int> mp;
    factorize(i, mp);
    LL r = (LL)calcd(mp);
    ans += r;
  }
  printf("%lld\\n", ans);
  return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>

#include <bits/stdc++.h>
#include <cmath>
#include <limits>

using namespace std;
typedef long long LL;
using Graph = vector<vector<int>>;

static long long INF = (1LL << 62);

int isPrime(LL p) {
  if (p <= 1)
    return 0;
  if (p == 2 || p == 3 || p == 5 || p == 7)
    return 1;
  if (p == 4 || p == 6 || p == 8 || p == 9)
    return 0;

  LL i;
  int ret = 1;
  for (i = 2; i * i <= p; i++) {
    if (p % i == 0 && i != p) {
      ret = 0;
      break;
    }
  }
  return ret;
}

LL calcd(map<LL, int> &mp) {
  LL ret = 1;
  for (auto itr = mp.begin(); itr != mp.end(); itr++) {
    int v = itr->second;
    ret *= (v + 1);
  }
  return ret;
}

LL N;
vector<LL> spf;
void init(LL n) {
  spf.assign(n + 1, 0);
  for (LL i = 0; i <= n; i++)
    spf[i] = i;
  for (LL i = 2; i * i <= n; i++) {
    if (spf[i] == i) {
      for (LL j = i * i; j <= n; j += i) {
        if (spf[j] == j) {
          spf[j] = i;
        }
      }
    }
  }
}

map<LL, int> get(LL n) {
  map<LL, int> m;
  while (n != 1) {
    m[spf[n]]++;
    n /= spf[n];
  }
  return m;
}
int main(int argc, char *argv[]) {
  cin.tie(0);
  ios::sync_with_stdio(false);

  cin >> N;
  init(N);

  LL ans = 0;
  for (LL i = 1; i < N; i++) {
    map<LL, int> mp = get(i);
    LL r = (LL)calcd(mp);
    ans += r;
  }
  printf("%lld\\n", ans);
  return 0;
}


#include <bits/stdc++.h>
#define sz(x) ((int)(x).size())
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;

typedef long long lld;
typedef vector<lld> vlld;
const lld mod = (lld)1e9 + 7;

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

  cout << ans << "\\n";
  return 0;
}

#include <bits/stdc++.h>
#define sz(x) ((int)(x).size())
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;

typedef long long lld;
typedef vector<lld> vlld;
const lld mod = (lld)1e9 + 7;

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

  cout << ans << "\\n";
  return 0;
}


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

#define int long long
#define ld long double
#define F first
#define S second
#define PB push_back
#define FOR(i, a, b) for (i = a; i <= b; i++)
#define RFOR(i, a, b) for (i = a; i >= b; i--)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define clr(x, f) memset(x, f, sizeof(x))
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define si set<int>
#define spii set<pii>
#define usi unordered_set<int>
#define uspii unordered_set<pii>
#define mii map<int, int>
#define umii unordered_map<int, int>
#define pqmx priority_queue<int>
#define pqmn priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define tzbits(x) __builtin_ctzll(x)
#define lzbits(x) __builtin_clzll(x)
#define pbits(x) __builtin_parityll(x)
#define gcd __gcd
#define lcm(x, y) ((x) * (y)) / gcd(x, y)
#define endl '\\n'
#define sz(s) (int)s.size()
#define sp(x, y) fixed << setprecision(y) << x
const int mod = 1000000007;
const int inf = 1000000000000000000;
const ld PI = 3.1415926535897932384626;
const ld eps = 1e-12;
void __print(int32_t x) { cout << x; }
void __print(int x) { cout << x; }
void __print(double x) { cout << x; }
void __print(ld x) { cout << x; }
void __print(float x) { cout << x; }
void __print(bool x) { cout << (x ? "true" : "false"); }
void __print(char x) { cout << '\\'' << x << '\\''; }
void __print(const char *x) { cout << '\\"' << x << '\\"'; }
void __print(const string &x) { cout << '\\"' << x << '\\"'; }
template <typename T, typename V> void __print(const pair<T, V> &x) {
  cout << '{';
  __print(x.first);
  cout << ',';
  __print(x.second);
  cout << '}';
}
template <typename T> void __print(const T &x) {
  int f = 0;
  cout << '{';
  for (auto &i : x)
    cout << (f++ ? "," : ""), __print(i);
  cout << "}";
}
void _print() { cout << "]\\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
  __print(t);
  if (sizeof...(v))
    cout << ", ";
  _print(v...);
}
#define dbg(x...)                                                              \\
  cout << "[" << #x << "]=[";                                                  \\
  _print(x)
int powerm(int base, int exp) {
  int res = 1;
  base %= mod;
  while (exp > 0) {
    if (exp & 1)
      res = (res * base) % mod;
    base = (base * base) % mod;
    exp = exp >> 1;
  }
  return res;
}
int power(int base, int exp) {
  int res = 1;
  while (exp > 0) {
    if (exp & 1)
      res = res * base;
    base = base * base;
    exp = exp >> 1;
  }
  return res;
}
float powerNeg(float base, int exp) {
  float temp;
  if (exp == 0)
    return 1;
  temp = powerNeg(base, exp / 2);
  if (exp % 2 == 0)
    return temp * temp;
  else {
    if (exp > 0)
      return base * temp * temp;
    else
      return (temp * temp) / base;
  }
}
int modinv(int exp) { return powerm(exp, mod - 2); }
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

const int N = 2e6 + 5, M = N;

void solve() {

  int i, j;
  int n;
  cin >> n;

  int ans = 0;
  for (int c = 1; c < n; c++) {
    int x = n - c;
    for (int a = 1; a * a <= x; a++) {
      if (x % a == 0) {
        if (x / a == a)
          ans++;
        else
          ans += 2;
      }
    }
  }

  cout << ans << endl;
}

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

  int t, T = 1;
  // cin>>T;
  FOR(t, 1, T) {
    // cout<<"Case #"<<i<<": ";
    solve();
  }
  // cout<<endl<<"Times Elapsed:"<<1.0*clock()/CLOCKS_PER_SEC<<"sec";
  return 0;
}

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

#define int long long
#define ld long double
#define F first
#define S second
#define PB push_back
#define FOR(i, a, b) for (i = a; i <= b; i++)
#define RFOR(i, a, b) for (i = a; i >= b; i--)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define clr(x, f) memset(x, f, sizeof(x))
#define pii pair<int, int>
#define vi vector<int>
#define vpii vector<pii>
#define vvi vector<vi>
#define si set<int>
#define spii set<pii>
#define usi unordered_set<int>
#define uspii unordered_set<pii>
#define mii map<int, int>
#define umii unordered_map<int, int>
#define pqmx priority_queue<int>
#define pqmn priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define tzbits(x) __builtin_ctzll(x)
#define lzbits(x) __builtin_clzll(x)
#define pbits(x) __builtin_parityll(x)
#define gcd __gcd
#define lcm(x, y) ((x) * (y)) / gcd(x, y)
#define endl '\\n'
#define sz(s) (int)s.size()
#define sp(x, y) fixed << setprecision(y) << x
const int mod = 1000000007;
const int inf = 1000000000000000000;
const ld PI = 3.1415926535897932384626;
const ld eps = 1e-12;
void __print(int32_t x) { cout << x; }
void __print(int x) { cout << x; }
void __print(double x) { cout << x; }
void __print(ld x) { cout << x; }
void __print(float x) { cout << x; }
void __print(bool x) { cout << (x ? "true" : "false"); }
void __print(char x) { cout << '\\'' << x << '\\''; }
void __print(const char *x) { cout << '\\"' << x << '\\"'; }
void __print(const string &x) { cout << '\\"' << x << '\\"'; }
template <typename T, typename V> void __print(const pair<T, V> &x) {
  cout << '{';
  __print(x.first);
  cout << ',';
  __print(x.second);
  cout << '}';
}
template <typename T> void __print(const T &x) {
  int f = 0;
  cout << '{';
  for (auto &i : x)
    cout << (f++ ? "," : ""), __print(i);
  cout << "}";
}
void _print() { cout << "]\\n"; }
template <typename T, typename... V> void _print(T t, V... v) {
  __print(t);
  if (sizeof...(v))
    cout << ", ";
  _print(v...);
}
#define dbg(x...)                                                              \\
  cout << "[" << #x << "]=[";                                                  \\
  _print(x)
int powerm(int base, int exp) {
  int res = 1;
  base %= mod;
  while (exp > 0) {
    if (exp & 1)
      res = (res * base) % mod;
    base = (base * base) % mod;
    exp = exp >> 1;
  }
  return res;
}
int power(int base, int exp) {
  int res = 1;
  while (exp > 0) {
    if (exp & 1)
      res = res * base;
    base = base * base;
    exp = exp >> 1;
  }
  return res;
}
float powerNeg(float base, int exp) {
  float temp;
  if (exp == 0)
    return 1;
  temp = powerNeg(base, exp / 2);
  if (exp % 2 == 0)
    return temp * temp;
  else {
    if (exp > 0)
      return base * temp * temp;
    else
      return (temp * temp) / base;
  }
}
int modinv(int exp) { return powerm(exp, mod - 2); }
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

const int N = 2e6 + 5, M = N;
vi fact(N, 2);
void sieve() {
  fact[0] = 0;
  fact[1] = 1;
  for (int i = 2; i < N; i++) {
    for (int j = 2 * i; j < N; j += i) {
      fact[j]++;
    }
  }
}
void solve() {

  int i, j;
  int n;
  cin >> n;
  sieve();
  // dbg(fact);
  int ans = 0;
  for (int c = 1; c < n; c++) {
    int x = n - c;
    ans += fact[x];
    // ans-=1;
    // for(int a=1;a*a<=x;a++){
    //     if(x%a==0){
    //         if(x/a==a) ans++;
    //         else ans+=2;
    //     }
    // }
  }

  cout << ans << endl;
}

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

  int t, T = 1;
  // cin>>T;
  FOR(t, 1, T) {
    // cout<<"Case #"<<i<<": ";
    solve();
  }
  // cout<<endl<<"Times Elapsed:"<<1.0*clock()/CLOCKS_PER_SEC<<"sec";
  return 0;
}


#include <bits/stdc++.h>
#define ll long long
#define ls id << 1
#define rs id << 1 | 1
#define mem(array, value, size, type)                                          \\
  memset(array, value, ((size) + 5) * sizeof(type))
#define memarray(array, value) memset(array, value, sizeof(array))
#define fillarray(array, value, begin, end)                                    \\
  fill((array) + (begin), (array) + (end) + 1, value)
#define fillvector(v, value) fill((v).begin(), (v).end(), value)
#define pb(x) push_back(x)
#define st(x) (1LL << (x))
#define pii pair<int, int>
#define mp(a, b) make_pair((a), (b))
#define Flush fflush(stdout)
#define vecfirst (*vec.begin())
#define veclast (*vec.rbegin())
#define vecall(v) (v).begin(), (v).end()
#define vecupsort(v) (sort((v).begin(), (v).end()))
#define vecdownsort(v, type) (sort(vecall(v), greater<type>()))
#define veccmpsort(v, cmp) (sort(vecall(v), cmp))
using namespace std;
const int N = 1000050;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
clock_t TIME__START, TIME__END;
void program_end() {
#ifdef ONLINE
  printf("\\n\\nTime used: %.6lf(s)\\n", ((double)TIME__END - TIME__START) / 1000);
  system("pause");
#endif
}
int n;
ll ans;

inline void solve() {
  cin >> n;
  for (int c = 1; c < n; ++c) {
    ll now = n - c;
    int cnt = 0;
    for (int d = 1; d * d < now; ++d) {
      if (now % d)
        continue;
      cnt++;
    }
    cnt <<= 1;
    if ((int)sqrt(now) * (int)sqrt(now) == now)
      cnt++;
    ans += cnt;
  }
  cout << ans;
}

int main() {
  TIME__START = clock();
  int Test = 1;
  // scanf("%d", &Test);
  while (Test--) {
    solve();
    // if (Test)
    //     putchar('\\n');
  }
  TIME__END = clock();
  program_end();
  return 0;
}

#include <bits/stdc++.h>
#define ll long long
#define ls id << 1
#define rs id << 1 | 1
#define mem(array, value, size, type)                                          \\
  memset(array, value, ((size) + 5) * sizeof(type))
#define memarray(array, value) memset(array, value, sizeof(array))
#define fillarray(array, value, begin, end)                                    \\
  fill((array) + (begin), (array) + (end) + 1, value)
#define fillvector(v, value) fill((v).begin(), (v).end(), value)
#define pb(x) push_back(x)
#define st(x) (1LL << (x))
#define pii pair<int, int>
#define mp(a, b) make_pair((a), (b))
#define Flush fflush(stdout)
#define vecfirst (*vec.begin())
#define veclast (*vec.rbegin())
#define vecall(v) (v).begin(), (v).end()
#define vecupsort(v) (sort((v).begin(), (v).end()))
#define vecdownsort(v, type) (sort(vecall(v), greater<type>()))
#define veccmpsort(v, cmp) (sort(vecall(v), cmp))
using namespace std;
const int N = 1000050;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
clock_t TIME__START, TIME__END;
void program_end() {
#ifdef ONLINE
  printf("\\n\\nTime used: %.6lf(s)\\n", ((double)TIME__END - TIME__START) / 1000);
  system("pause");
#endif
}
int n;
ll ans;
int vis[N], pri[N], tot;
void shaipri(int lim) {
  for (int i = 2; i <= lim; ++i) {
    if (!vis[i])
      vis[i] = i, pri[++tot] = i;
    for (int j = 1; j <= tot && i * pri[j] <= lim; ++j) {
      vis[i * pri[j]] = pri[j];
      if (i % pri[j] == 0)
        break;
    }
  }
}

inline void solve() {
  cin >> n;
  for (int c = 1; c < n; ++c) {
    ll now = n - c;
    ll tmp = 1;
    while (now > 1) {
      ll cnt = 1;
      int nowpri = vis[now];
      while (now % nowpri == 0)
        now /= nowpri, cnt++;
      tmp *= cnt;
    }
    ans += tmp;
  }
  cout << ans;
}

int main() {
  TIME__START = clock();
  int Test = 1;
  shaipri(1000000);
  // scanf("%d", &Test);
  while (Test--) {
    solve();
    // if (Test)
    //     putchar('\\n');
  }
  TIME__END = clock();
  program_end();
  return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define int long long
#define S second
#define F first
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define lb lower_bound
#define ub upper_bound
#define si(c) (int)((c).size())
#define lcm(a, b) (a * (b / __gcd(a, b)))
#define inf (int)(4e18)
#define endl '\\n'
#define mp make_pair
#define time(s) (double(clock() - s) / double(CLOCKS_PER_SEC))
#define debug(args...) _F(#args, args)
#define vi std::vector<int>
#define pii pair<int, int>
#define vpi vector<pii>
#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>

clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());

template <typename T> void _F(const char *name, T arg1) {
  cerr << name << " = " << arg1 << endl;
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
  const char *name = strchr(names, ',');
  cerr.write(names, name - names) << " = " << arg1 << endl;
  _F(name + 2, args...);
}

template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
  in >> q.F >> q.S;
  return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
  out << q.F << " " << q.S;
  return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
  return {p1.F + p2.F, p1.S + p2.S};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
  return {p1.F - p2.F, p1.S - p2.S};
}
template <typename T1, typename T2>
bool operator<(pair<T1, T2> p1, pair<T1, T2> p2) {
  return p1 < p2;
}

template <typename T> void Unique(vector<T> &v) {
  sort(all(v)), v.resize(distance(v.begin(), unique(all(v))));
}

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

  int ans = 0;
  for (int i = 1; i < n; i++) {
    int cur = n - i;

    for (int j = 1; j * j <= cur; j++) {
      if (cur % j == 0) {
        ans += (1 + (j != cur / j));
      }
    }
  }
  cout << ans << endl;
}

signed main() {

  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  start = clock();

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

  int test = 1;
  // cin >> test;

  cout << fixed << setprecision(2);

  for (int i = 1; i <= test; ++i) {
    solve();
  }

  cerr << time(start);
  return 0;
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define int long long
#define S second
#define F first
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define lb lower_bound
#define ub upper_bound
#define si(c) (int)((c).size())
#define lcm(a, b) (a * (b / __gcd(a, b)))
#define inf (int)(4e18)
#define endl '\\n'
#define mp make_pair
#define time(s) (double(clock() - s) / double(CLOCKS_PER_SEC))
#define debug(args...) _F(#args, args)
#define vi std::vector<int>
#define pii pair<int, int>
#define vpi vector<pii>
#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>

clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());

template <typename T> void _F(const char *name, T arg1) {
  cerr << name << " = " << arg1 << endl;
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
  const char *name = strchr(names, ',');
  cerr.write(names, name - names) << " = " << arg1 << endl;
  _F(name + 2, args...);
}

template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
  in >> q.F >> q.S;
  return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
  out << q.F << " " << q.S;
  return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
  return {p1.F + p2.F, p1.S + p2.S};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
  return {p1.F - p2.F, p1.S - p2.S};
}
template <typename T1, typename T2>
bool operator<(pair<T1, T2> p1, pair<T1, T2> p2) {
  return p1 < p2;
}

template <typename T> void Unique(vector<T> &v) {
  sort(all(v)), v.resize(distance(v.begin(), unique(all(v))));
}

const int N = 1e6 + 1;
int d[N];
void solve() {
  int n;
  cin >> n;

  int ans = 0;

  for (int i = 1; i <= n; i++) {
    for (int j = i; j <= n; j += i)
      d[j]++;
  }
  for (int i = 1; i < n; i++) {
    int cur = n - i;
    ans += d[cur];
  }
  cout << ans << endl;
}

signed main() {

  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  start = clock();

  int test = 1;
  // cin >> test;

  cout << fixed << setprecision(2);

  for (int i = 1; i <= test; ++i) {
    solve();
  }

  cerr << time(start);
  return 0;
}


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

ll gcd(ll a, ll b) {
  if (b > a)
    swap(a, b);
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
  ll g = gcd(a, b);
  return a / g * b;
}
ll rep_jijo(ll n, ll x) {
  if (x == 0)
    return 1;
  if (x % 2 == 0) {
    ll t = rep_jijo(n, x / 2);
    return t * t % mod;
  }
  return n * rep_jijo(n, x - 1) % mod;
}
ll c2(ll n) { return n * (n - 1) / 2; }
struct UnionFind {
  vector<int> d;
  UnionFind(int n = 0) : d(n, -1) {}
  int find(int x) {
    if (d[x] < 0)
      return x;
    return d[x] = find(d[x]);
  }
  bool unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (d[x] > d[y])
      swap(x, y);
    d[x] += d[y];
    d[y] = x;
    return true;
  }
  bool same(int x, int y) { return find(x) == find(y); }
  int size(int x) { return -d[find(x)]; }
};
int main() {
  ll n;
  cin >> n;
  ll m = n;
  ll ans = 0;
  rep(i, n) {
    m--;
    for (ll j = 1; j <= sqrt(m); j++) {
      if (m % j == 0)
        ans += 2;
      if (j == sqrt(m))
        ans--;
    }
  }

  cout << ans << endl;
}

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

ll gcd(ll a, ll b) {
  if (b > a)
    swap(a, b);
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
  ll g = gcd(a, b);
  return a / g * b;
}
ll rep_jijo(ll n, ll x) {
  if (x == 0)
    return 1;
  if (x % 2 == 0) {
    ll t = rep_jijo(n, x / 2);
    return t * t % mod;
  }
  return n * rep_jijo(n, x - 1) % mod;
}
ll c2(ll n) { return n * (n - 1) / 2; }
struct UnionFind {
  vector<int> d;
  UnionFind(int n = 0) : d(n, -1) {}
  int find(int x) {
    if (d[x] < 0)
      return x;
    return d[x] = find(d[x]);
  }
  bool unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y)
      return false;
    if (d[x] > d[y])
      swap(x, y);
    d[x] += d[y];
    d[y] = x;
    return true;
  }
  bool same(int x, int y) { return find(x) == find(y); }
  int size(int x) { return -d[find(x)]; }
};
int main() {
  ll n;
  cin >> n;
  ll ans = 0;

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


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

typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i < (int)(n); i++)

int divisors(int n) {
  int div = 0;
  rep1(i, int(sqrt(n)) + 1) {
    if (n % i == 0) {
      div += 1;
      if (i != n / i) {
        div += 1;
      }
    }
  }
  return div;
}

int N;
int dp[1100000];
int ans;

int main() {

  cin >> N;

  rep1(i, 1000001) dp[i] = divisors(i);
  rep1(i, 1000001) ans += dp[i];

  cout << ans << endl;
}

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

typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i < (int)(n); i++)

int divisors(int n) {
  int div = 0;
  rep1(i, int(sqrt(n)) + 1) {
    if (n % i == 0) {
      div += 1;
      if (i != n / i) {
        div += 1;
      }
    }
  }
  return div;
}

int N;
int dp[1100000];
int ass[1100000];

int main() {

  cin >> N;

  rep1(i, 1000001) dp[i] = divisors(i);
  rep1(i, 1000001) ass[i] = ass[i - 1] + dp[i];

  cout << ass[N - 1] << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = ((n)-1); (i) >= 0; (i)--)
#define itn int
#define miele(v) min_element(v.begin(), v.end())
#define maele(v) max_element(v.begin(), v.end())
#define SUM(v) accumulate(v.begin(), v.end(), 0LL)
#define lb(a, key) lower_bound(a.begin(), a.end(), key)
#define ub(a, key) upper_bound(a.begin(), a.end(), key)
#define COUNT(a, key) count(a.begin(), a.end(), key)
#define BITCOUNT(x) __builtin_popcount(x)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
using P = pair<int, int>;
using WeightedGraph = vector<vector<P>>;
using UnWeightedGraph = vector<vector<int>>;
using Real = long double;
using Point = complex<Real>; // Point and Vector2d is the same!
using Vector2d = complex<Real>;
const long long INF = 1LL << 60;
const int MOD = 1000000007;
const double EPS = 1e-15;
const double PI = 3.14159265358979323846;
template <typename T> int getIndexOfLowerBound(vector<T> &v, T x) {
  return lower_bound(v.begin(), v.end(), x) - v.begin();
}
template <typename T> int getIndexOfUpperBound(vector<T> &v, T x) {
  return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
#define DUMPOUT cerr
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
istream &operator>>(istream &is, Point &p) {
  Real a, b;
  is >> a >> b;
  p = Point(a, b);
  return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p_var) {
  is >> p_var.first >> p_var.second;
  return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
  DUMPOUT << '{';
  os << pair_var.first;
  DUMPOUT << ',';
  os << " " << pair_var.second;
  DUMPOUT << '}';
  return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
  DUMPOUT << '[';
  for (int i = 0; i < vec.size(); i++)
    os << vec[i] << (i + 1 == vec.size() ? "" : " ");
  DUMPOUT << ']';
  return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &df) {
  for (auto &vec : df)
    os << vec;
  return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
  DUMPOUT << "{";
  repi(itr, map_var) {
    os << *itr;
    itr++;
    if (itr != map_var.end())
      DUMPOUT << ", ";
    itr--;
  }
  DUMPOUT << "}";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
  DUMPOUT << "{";
  repi(itr, set_var) {
    os << *itr;
    itr++;
    if (itr != set_var.end())
      DUMPOUT << ", ";
    itr--;
  }
  DUMPOUT << "}";
  return os;
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
  cout << head;
  if (sizeof...(tail) != 0)
    cout << " ";
  print(forward<Tail>(tail)...);
}
void dump_func() { DUMPOUT << '#' << endl; }
template <typename Head, typename... Tail>
void dump_func(Head &&head, Tail &&...tail) {
  DUMPOUT << head;
  if (sizeof...(Tail) > 0)
    DUMPOUT << ", ";
  dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...)                                                              \\
  DUMPOUT << "  " << string(#__VA_ARGS__) << ": "                              \\
          << "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl  \\
          << "    ",                                                           \\
      dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif

template <typename T> T power(T x, int n) {
  T ret = 1;
  while (n > 0) {
    if (n & 1)
      (ret *= x);
    (x *= x);
    n >>= 1;
  }
  return ret;
}

int DIV(int n) {
  int cnt = 0;
  for (int i = 1; i * i <= n; ++i) {
    if (n % i == 0) {
      cnt++;
      if (i * i != n)
        cnt++;
    }
  }

  return (cnt);
}

int main(void) {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  int ans = 0;
  for (int j = 1; j <= n - 1; ++j) {
    for (int i = 1; i * i <= j; ++i) {
      if (j % i == 0) {
        ans++;
        if (i * i != j)
          ans++;
      }
    }
  }
  cout << ans << '\\n';
}

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int(i) = ((n)-1); (i) >= 0; (i)--)
#define int long long
#define miele(v) min_element(v.begin(), v.end())
#define maele(v) max_element(v.begin(), v.end())
#define SUM(v) accumulate(v.begin(), v.end(), 0LL)
#define lb(a, key) lower_bound(a.begin(), a.end(), key)
#define ub(a, key) upper_bound(a.begin(), a.end(), key)
#define COUNT(a, key) count(a.begin(), a.end(), key)
#define BITCOUNT(x) __builtin_popcount(x)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
using P = pair<int, int>;
using WeightedGraph = vector<vector<P>>;
using UnWeightedGraph = vector<vector<int>>;
using Real = long double;
using Point = complex<Real>; // Point and Vector2d is the same!
using Vector2d = complex<Real>;
const long long INF = 1LL << 60;
const int MOD = 1000000007;
const double EPS = 1e-15;
const double PI = 3.14159265358979323846;
template <typename T> int getIndexOfLowerBound(vector<T> &v, T x) {
  return lower_bound(v.begin(), v.end(), x) - v.begin();
}
template <typename T> int getIndexOfUpperBound(vector<T> &v, T x) {
  return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
#define DUMPOUT cerr
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
istream &operator>>(istream &is, Point &p) {
  Real a, b;
  is >> a >> b;
  p = Point(a, b);
  return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p_var) {
  is >> p_var.first >> p_var.second;
  return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
  for (T &x : vec)
    is >> x;
  return is;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
  DUMPOUT << '{';
  os << pair_var.first;
  DUMPOUT << ',';
  os << " " << pair_var.second;
  DUMPOUT << '}';
  return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec) {
  DUMPOUT << '[';
  for (int i = 0; i < vec.size(); i++)
    os << vec[i] << (i + 1 == vec.size() ? "" : " ");
  DUMPOUT << ']';
  return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<vector<T>> &df) {
  for (auto &vec : df)
    os << vec;
  return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
  DUMPOUT << "{";
  repi(itr, map_var) {
    os << *itr;
    itr++;
    if (itr != map_var.end())
      DUMPOUT << ", ";
    itr--;
  }
  DUMPOUT << "}";
  return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> &set_var) {
  DUMPOUT << "{";
  repi(itr, set_var) {
    os << *itr;
    itr++;
    if (itr != set_var.end())
      DUMPOUT << ", ";
    itr--;
  }
  DUMPOUT << "}";
  return os;
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
  cout << head;
  if (sizeof...(tail) != 0)
    cout << " ";
  print(forward<Tail>(tail)...);
}
void dump_func() { DUMPOUT << '#' << endl; }
template <typename Head, typename... Tail>
void dump_func(Head &&head, Tail &&...tail) {
  DUMPOUT << head;
  if (sizeof...(Tail) > 0)
    DUMPOUT << ", ";
  dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...)                                                              \\
  DUMPOUT << "  " << string(#__VA_ARGS__) << ": "                              \\
          << "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl  \\
          << "    ",                                                           \\
      dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif

signed main(void) {
  cin.tie(0);
  ios::sync_with_stdio(false);
  int n;
  cin >> n;
  int ans = 0;

  for (int i = 1; i <= n - 1; i++) {
    int l = -1, r = 1000000; // l,rの範囲にめっちゃ注意!
    while (abs(l - r) > 1) {
      int mid = l + (r - l) / 2;
      if (mid * i < n)
        l = mid;
      else
        r = mid;
    }
    ans += l;
    // dump(l, i);
  }
  print(ans);
}


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

#define ll long long int
#define scan(any)                                                              \\
  for (auto &i : any)                                                          \\
    cin >> i;
#define print(any)                                                             \\
  for (auto i : any)                                                           \\
    cout << i << " ";
#define endl '\\n'
#define pb push_back
#define vll vector<ll>
#define f(i, x, y) for (i = x; i < y; i++)
#define INF LLONG_MAX
#define fast                                                                   \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define s(x) sort(x.begin(), x.end())
#define all(v) v.begin(), v.end()
#define p2(n, x) cout << fixed << setprecision(x) << n << endl;
#define pll pair<ll, ll>
#define ff first
#define ss second
#define blt(x) __builtin_popcount(x)
ll fun(ll n) {

  ll ans = 0;
  ll i, j, k;
  f(i, 1, (int)sqrt(n) + 1) {
    if (n % i == 0) {
      if (i == n / i)
        ans++;
      else
        ans += 2;
    }
  }
  return ans;
}
void solve() {
  ll i, j, k, n;
  cin >> n;
  ll ans = 0;
  f(i, 1, n) { ans += fun(n - i); }
  cout << ans;
}

int main() {

  fast ll t = 1;

  while (t--)
    solve();

  return 0;
}

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

#define ll long long int
#define scan(any)                                                              \\
  for (auto &i : any)                                                          \\
    cin >> i;
#define print(any)                                                             \\
  for (auto i : any)                                                           \\
    cout << i << " ";
#define endl '\\n'
#define pb push_back
#define vll vector<ll>
#define f(i, x, y) for (i = x; i < y; i++)
#define INF LLONG_MAX
#define fast                                                                   \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define s(x) sort(x.begin(), x.end())
#define all(v) v.begin(), v.end()
#define p2(n, x) cout << fixed << setprecision(x) << n << endl;
#define pll pair<ll, ll>
#define ff first
#define ss second
#define blt(x) __builtin_popcount(x)

void solve() {
  ll i, j, k, n;
  cin >> n;
  ll a = 0;
  f(i, 1, n) a += ((n - 1) / i);
  cout << a;
}

int main() {

  fast ll t = 1;

  while (t--)
    solve();

  return 0;
}


#include <bits/stdc++.h>
#define mod 1000000007
#define f first
#define s second
using namespace std;

void solve() {
  int n;
  cin >> n;
  long count = 0;
  for (int i = 1; i < n; i++) {
    for (int j = 1; j < n; j++) {
      for (int k = 1; k < n; k++) {
        if ((i * j + k) == n) {
          count++;
        }
      }
    }
  }
  cout << count << endl;
}

int main() {

  /*#ifndef ONLINE_JUDGE
          freopen("input.txt","r",stdin);
          freopen("output.txt","w",stdout);
  #endif*/
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  // int t;cin >> t;while(t--){solve();}
  solve();
  return 0;
}

#include <bits/stdc++.h>
#define mod 1000000007
#define f first
#define s second
using namespace std;

void solve() {
  long long n;
  cin >> n;
  long long sum = 0;
  for (int i = 1; i < n; ++i) {
    sum += (n - 1) / i;
  }

  cout << sum << endl;
}

int main() {

  /*#ifndef ONLINE_JUDGE
          freopen("input.txt","r",stdin);
          freopen("output.txt","w",stdout);
  #endif*/
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  // int t;cin >> t;while(t--){solve();}
  solve();
  return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int N = 2e5 + 5;

typedef tree<int, null_type, less<int>, rb_tree_tag,
             tree_order_statistics_node_update>
    orderset;

vector<ll> sieve(ll n) {
  bool prim[n + 1];
  memset(prim, true, sizeof(prim));

  for (ll p = 2; p * p <= n; p++) {
    if (prim[p] == true) {
      for (ll i = p * p; i <= n; i += p)
        prim[i] = false;
    }
  }
  vector<ll> vec;
  for (int i = 2; i <= n; i++) {
    if (prim[i]) {
      vec.push_back((ll)i);
    }
  }
  return vec;
}

ll divisor(ll n) {
  ll ans = 0;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      int r = i;
      int l = n / i;
      if (r == l)
        ans++;
      else if (r != l)
        ans += 2;
      // st.insert(i);st.insert(n/i);
    }
  }
  return ans;
}
void solve() {
  ll n;
  cin >> n;
  ll anss = 0;
  for (ll i = 1; i <= n; i++) {
    if (i != n)
      anss += divisor(n - i);
  }
  cout << anss << "\\n";
}

int main() {
  /*#ifndef ONLINE_JUDGE
      freopen("input.txt", "r", stdin);
      freopen("output.txt", "w", stdout);
  #endif*/
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int T = 1;
  // cin>>T;
  while (T--) {
    solve();
  }
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;

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

int main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int T = 1;
  // cin>>T;
  while (T--) {
    solve();
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
ll Div(ll n) {
  ll res = 0;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      res++;
      ll j = n / i;
      if (j != i)
        res++;
    }
  }
  return res;
}
int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  for (ll i = 1; i < n; i++) {
    ll x = Div(i);
    ans += x;
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
vector<ll> NUM(1e6 + 20, 1);
void Div(ll n) {
  for (ll i = 2; i <= n; i++) {
    for (ll j = i; j <= n; j += i) {
      NUM[j]++;
    }
  }
}
int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  Div(1e6);
  for (ll i = 1; i < n; i++) {
    ans += NUM[i];
  }
  cout << ans << endl;
}


// Nihal Mittal - nihal_47
// Strike First , Strike Hard , No Mercy !!

/**⠀⠀⠀⠀⠀⠀⣀⣤⣤⣄⣀
⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣀
⠀⠀⠀⠀⣰⣿⣿⣿⣿⠿⠿⣿⣿⣿⣿⣿⣿⣿⣧⢀
⠀⠀⠀⣿⣿⣿⠋⠀⠀⠀⠀⠀⠙⠀⠙⣿⣿⣿⣷⢳⢀
⠀⠀⣠⣿⣿⣿⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⢀
⠀⠀⣸⣿⣿⣿⠸⠀⠀⠀⠒⠒⠒⠐⠀⠀⢿⣿⣿⣿⣿⣿
⠀⣴⣿⣿⣿⡿⠀⠒⣋⣙⡒⢰⠀⠤⣖⠒⢾⣿⣿⣿⣿⣧
⢺⣿⣿⣿⣿⢀⠀⠀⠉⠉⠉⠸⠀⡇⠉⠉⠀⢿⣿⣿⣿⣄
⠀⠙⣿⣿⣧⢻⠀⠀⠀⠀⠀⠠⠀⠰⠀⠀⠀⣸⠸⣿⣿⠿⠰
⠀⠀⠀⠹⣿⣿⣿⣷⠀⡠⠙⣲⣔⣅⢡⣰⣷⣿⣿⣿⣧
⠀⠀⠀⣼⣿⣿⣿⣿⠀⡿⠭⠭⠭⠭⢿⠀⣿⢻⣿⣿⠃
⠀⠀⠀⠙⠛⣿⢻⠹⣿⠐⠙⠛⠟⠉⢀⣴⡟⢿⣿⡏
⠀⠀⠀⠀⠀⠀⡟⠀⠀⠻⣦⣤⣶⠾⠋⠀⠀⠁⡦⢄⢀
⠀⠀⠀⠀⡠⠁⡇⠑⢄⠀⠀⠀⠀⠀⠀⠔⠀⠀⠁⠀⠀⠀⠉⠁
⠀⠔⠊⠁⠀⠀⣇⠀⠀⠀⠑⡤⠤⢎⠁⠀⠀⡘
⠀⠀⠀⠀⠀⠀⢢⠠⠀⡠⢆⠀⠀⡠⠙⢄⠀⡸
**/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll int
#define ld long double
#define mk make_pair
#define pb push_back
#define in insert
#define se second
#define fi first
#define mod 1000000007
#define watch(x) cout << (#x) << " is " << (x) << "\\n"
#define all(v) (v).begin(), (v).end()
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(0);
#define printclock                                                             \\
  cerr << "Time : " << 1000 * (ld)clock() / (ld)CLOCKS_PER_SEC << "ms\\n";
#define pii pair<ll, ll>
#define vi(x) vector<x>
#define maxn 100005
#define ordered_set                                                            \\
  tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
using namespace __gnu_pbds;

signed main() {
  fast;

  ll n, i, j, ans = 0;
  cin >> n;
  for (i = 1; i < n; i++) {
    for (j = 1; j <= sqrt(n - i); j++) {
      if ((n - i) % j == 0) {
        ll ha = (n - i) / j;
        if (ha == j)
          ans += 1;
        else
          ans += 2;
      }
    }
  }
  cout << ans;
}

// Nihal Mittal - nihal_47
// Strike First , Strike Hard , No Mercy !!

/**⠀⠀⠀⠀⠀⠀⣀⣤⣤⣄⣀
⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⣀
⠀⠀⠀⠀⣰⣿⣿⣿⣿⠿⠿⣿⣿⣿⣿⣿⣿⣿⣧⢀
⠀⠀⠀⣿⣿⣿⠋⠀⠀⠀⠀⠀⠙⠀⠙⣿⣿⣿⣷⢳⢀
⠀⠀⣠⣿⣿⣿⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣿⣿⣿⢀
⠀⠀⣸⣿⣿⣿⠸⠀⠀⠀⠒⠒⠒⠐⠀⠀⢿⣿⣿⣿⣿⣿
⠀⣴⣿⣿⣿⡿⠀⠒⣋⣙⡒⢰⠀⠤⣖⠒⢾⣿⣿⣿⣿⣧
⢺⣿⣿⣿⣿⢀⠀⠀⠉⠉⠉⠸⠀⡇⠉⠉⠀⢿⣿⣿⣿⣄
⠀⠙⣿⣿⣧⢻⠀⠀⠀⠀⠀⠠⠀⠰⠀⠀⠀⣸⠸⣿⣿⠿⠰
⠀⠀⠀⠹⣿⣿⣿⣷⠀⡠⠙⣲⣔⣅⢡⣰⣷⣿⣿⣿⣧
⠀⠀⠀⣼⣿⣿⣿⣿⠀⡿⠭⠭⠭⠭⢿⠀⣿⢻⣿⣿⠃
⠀⠀⠀⠙⠛⣿⢻⠹⣿⠐⠙⠛⠟⠉⢀⣴⡟⢿⣿⡏
⠀⠀⠀⠀⠀⠀⡟⠀⠀⠻⣦⣤⣶⠾⠋⠀⠀⠁⡦⢄⢀
⠀⠀⠀⠀⡠⠁⡇⠑⢄⠀⠀⠀⠀⠀⠀⠔⠀⠀⠁⠀⠀⠀⠉⠁
⠀⠔⠊⠁⠀⠀⣇⠀⠀⠀⠑⡤⠤⢎⠁⠀⠀⡘
⠀⠀⠀⠀⠀⠀⢢⠠⠀⡠⢆⠀⠀⡠⠙⢄⠀⡸
**/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define ld long double
#define mk make_pair
#define pb push_back
#define in insert
#define se second
#define fi first
#define mod 1000000007
#define watch(x) cout << (#x) << " is " << (x) << "\\n"
#define all(v) (v).begin(), (v).end()
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(0);
#define printclock                                                             \\
  cerr << "Time : " << 1000 * (ld)clock() / (ld)CLOCKS_PER_SEC << "ms\\n";
#define pii pair<ll, ll>
#define vi(x) vector<x>
#define maxn 100005
#define ordered_set                                                            \\
  tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
using namespace __gnu_pbds;
ll divi[2000006];
signed main() {
  fast;

  ll n, i, j, ans = 1;
  cin >> n;
  for (i = 1; i <= 1000006; i++) {
    for (j = i; j <= 1000006; j += i) {
      divi[j]++;
    }
  }

  for (i = 2; i < n; i++) {
    ans += divi[i];
  }
  cout << ans;
}


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

struct Union {
  vector<ll> par;
  Union(ll a) { par = vector<ll>(a, -1); }
  ll find(ll a) {
    if (par[a] < 0) {
      return a;
    } else {
      return par[a] = find(par[a]);
    }
  }
  bool same(ll a, ll b) { return (find(a) == find(b)); }
  ll size(ll a) { return -par[find(a)]; }
  void unite(ll a, ll b) {
    ll c = find(a), d = find(b);
    if (c == d)
      return;
    if (size(c) < size(d)) {
      swap(c, d);
    }
    par[c] += par[d];
    par[d] = c;
  }
};
ll euclidean_gcd(ll a, ll b) {
  if (a < b)
    return euclidean_gcd(b, a);
  ll r;
  while ((r = a % b)) {
    a = b;
    b = r;
  }
  return b;
}
ll euclidean_lcm(ll a, ll b) { return a / euclidean_gcd(a, b) * b; }

ll binary(ll bina) {
  ll ans = 0;
  for (ll i = 0; bina > 0; i++) {
    ans += bina % 2;
    bina = bina / 2;
  }
  return ans;
}
void revStr(char *str) {
  int size = strlen(str);
  int i, j;
  char tmp = {0};

  for (i = 0, j = size - 1; i < size / 2; i++, j--) {
    tmp = str[i];
    str[i] = str[j];
    str[j] = tmp;
  }
  return;
}

const int MAX = 510000;
const int MOD = 1000000007;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}

// 二項係数計算
long long COM(int n, int k) {
  if (n < k)
    return 0;
  if (n < 0 || k < 0)
    return 0;
  return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(void) {
  ll n, s = 0;
  cin >> n;
  rep(i, n - 1) { s += (n - 1) / i; }
  cout << s;
}

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

struct Union {
  vector<ll> par;
  Union(ll a) { par = vector<ll>(a, -1); }
  ll find(ll a) {
    if (par[a] < 0) {
      return a;
    } else {
      return par[a] = find(par[a]);
    }
  }
  bool same(ll a, ll b) { return (find(a) == find(b)); }
  ll size(ll a) { return -par[find(a)]; }
  void unite(ll a, ll b) {
    ll c = find(a), d = find(b);
    if (c == d)
      return;
    if (size(c) < size(d)) {
      swap(c, d);
    }
    par[c] += par[d];
    par[d] = c;
  }
};
ll euclidean_gcd(ll a, ll b) {
  if (a < b)
    return euclidean_gcd(b, a);
  ll r;
  while ((r = a % b)) {
    a = b;
    b = r;
  }
  return b;
}
ll euclidean_lcm(ll a, ll b) { return a / euclidean_gcd(a, b) * b; }

ll binary(ll bina) {
  ll ans = 0;
  for (ll i = 0; bina > 0; i++) {
    ans += bina % 2;
    bina = bina / 2;
  }
  return ans;
}
void revStr(char *str) {
  int size = strlen(str);
  int i, j;
  char tmp = {0};

  for (i = 0, j = size - 1; i < size / 2; i++, j--) {
    tmp = str[i];
    str[i] = str[j];
    str[j] = tmp;
  }
  return;
}

const int MAX = 510000;
const int MOD = 1000000007;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}

// 二項係数計算
long long COM(int n, int k) {
  if (n < k)
    return 0;
  if (n < 0 || k < 0)
    return 0;
  return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(void) {
  ll n, s = 0;
  cin >> n;
  rep(i, n) {
    if (i > 0)
      s = s + (n - 1) / i;
  }
  cout << s;
}


#include <bits/stdc++.h>

#define ll long long

#define ull unsigned long long

#define pii pair<int, int>

#define pll pair<ll int, ll int>

#define ff first

#define ss second

#define pb push_back

#define eb emplace_back

#define debug(n) cout << "DEBUG1 " << n << "\\n";

#define debug2(n, m) cout << "DEBUG2 " << n << ' ' << m << "\\n";

#define debug3(n, m, x) cout << "DEBUG3 " << n << ' ' << m << ' ' << x << "\\n";

#define debug4(n, m, x, y)                                                     \\
  cout << "DEBUG4 " << n << ' ' << m << ' ' << x << ' ' << y << "\\n";

#define ss_def                                                                 \\
  stringstream ss // stringstream, do ss_def(str), then ss >> n (n is int)

#define upzero(n)                                                              \\
  if (n < 0)                                                                   \\
  n = 0

#define alive(n) cout << "Alive here: checkpoint " << n << endl

#pragma GCC optimize("Ofast")

using namespace std;

void yes() {

  cout << "YES\\n";

  return;
}

void no() {

  cout << "NO\\n";

  return;
}

void init() {

  // initialize
}

int pp(int n) {

  int cnt = 0;

  for (int i = 1; i < ceil(sqrt(n)); i++) {

    if (n % i == 0)
      cnt += 2;
  }

  if (floor(sqrt(n)) * floor(sqrt(n)) == n)
    cnt++;

  return cnt;
}

void solve(int case_no) {

  // implementation

  int n;

  cin >> n;

  ll int ans = 0;

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

    ans += pp(i);
  }

  cout << ans << endl;
}

int main() {

  ios::sync_with_stdio(false);

  cin.tie(NULL);

  cout.tie(NULL);

  srand(time(NULL));

  init();

  int t = 1;

  //    cin >> t;

  for (int i = 1; i <= t; i++)
    solve(i);
}

/*

*/

#include <bits/stdc++.h>

#define ll long long

#define ull unsigned long long

#define pii pair<int, int>

#define pll pair<ll int, ll int>

#define ff first

#define ss second

#define pb push_back

#define eb emplace_back

#define debug(n) cout << "DEBUG1 " << n << "\\n";

#define debug2(n, m) cout << "DEBUG2 " << n << ' ' << m << "\\n";

#define debug3(n, m, x) cout << "DEBUG3 " << n << ' ' << m << ' ' << x << "\\n";

#define debug4(n, m, x, y)                                                     \\
  cout << "DEBUG4 " << n << ' ' << m << ' ' << x << ' ' << y << "\\n";

#define ss_def                                                                 \\
  stringstream ss // stringstream, do ss_def(str), then ss >> n (n is int)

#define upzero(n)                                                              \\
  if (n < 0)                                                                   \\
  n = 0

#define alive(n) cout << "Alive here: checkpoint " << n << endl

#pragma GCC optimize("Ofast")

using namespace std;

void yes() {

  cout << "YES\\n";

  return;
}

void no() {

  cout << "NO\\n";

  return;
}

void init() {

  // initialize
}

int pp(int n) {

  int cnt = 0;

  for (int i = 1; i < ceil(sqrt(n)); i++) {

    if (n % i == 0)
      cnt += 2;
  }

  if (floor(sqrt(n)) * floor(sqrt(n)) == n)
    cnt++;

  return cnt;
}

void solve(int case_no) {

  // implementation

  int n;

  cin >> n;

  int cnt[n + 1] = {0};

  ll int ans = 0;

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

    for (int j = i; j <= n; j += i) {

      cnt[j]++;
    }
  }

  for (int i = 1; i < n; i++)
    ans += cnt[i];

  cout << ans << endl;
}

int main() {

  ios::sync_with_stdio(false);

  cin.tie(NULL);

  cout.tie(NULL);

  srand(time(NULL));

  init();

  int t = 1;

  //    cin >> t;

  for (int i = 1; i <= t; i++)
    solve(i);
}

/*

*/


#include <bits/stdc++.h>

using namespace std;

#define int long long
#define ALL(x) (x).begin(), (x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))

typedef pair<int, int> PI;
typedef pair<int, pair<int, int>> PII;
static const int INF = 1010000000000000017LL;
static const double eps = 1e-12;
static const double pi = 3.14159265358979323846;
static const int dx[4] = {1, -1, 0, 0};
static const int dy[4] = {0, 0, 1, -1};
static const int ddx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
static const int ddy[8] = {0, 0, 1, -1, 1, -1, 1, -1};

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

int N;
bool used[1000005];

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

int ans;

signed main() {
  cin >> N;
  for (int C = 1; C < N; ++C) {
    int c = divisor(N - C);
    ans += (c / 2) * 2;
    if (c % 2 != 0)
      ans++;
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>

using namespace std;

#define int long long
#define ALL(x) (x).begin(), (x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))

typedef pair<int, int> PI;
typedef pair<int, pair<int, int>> PII;
static const int INF = 1010000000000000017LL;
static const double eps = 1e-12;
static const double pi = 3.14159265358979323846;
static const int dx[4] = {1, -1, 0, 0};
static const int dy[4] = {0, 0, 1, -1};
static const int ddx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
static const int ddy[8] = {0, 0, 1, -1, 1, -1, 1, -1};

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

int N;
int ans;

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


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

int main() {
  int N;
  cin >> N;
  vector<int> pre(N + 1, 0);

  for (int a = 1; a <= N; ++a) {
    for (int b = 1; b <= N / a; ++b) {
      ++pre[a * b];
    }
  }

  int sum = 0;

  for (int i = 1; i <= N; ++i)
    sum += pre[i];

  return sum;
}

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

int main() {
  int N;
  cin >> N;
  vector<int> pre(N + 1, 0);

  for (int a = 1; a <= N; ++a) {
    for (int b = 1; b <= N / a; ++b) {
      ++pre[a * b];
    }
  }

  int sum = 0;

  for (int i = 1; i < N; ++i)
    sum += pre[i];

  cout << sum;
  return 0;
}


#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;

using ll = long long;
const int INF = 1001001001;
const ll LLINF = 1001001001001001001;
const int MOD = 1000000007;

#define rep(i, n) for (int i = 0; i < (n); ++i)

ll yakusu(ll n) {
  ll ret = 0;

  for (ll i = 1; i * i <= n;
       i++) { // ルートnまで試す。i <= sqrt(n) だと、右辺が少数になってメンドイ
    if (n % i == 0) {
      ret++;
      if (n / i != i) { // ルートnが約数の時は、2つpush_backしないように注意
        ret++;
      }
    }
  }
  return ret;
}

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

  ll res = 0;

  for (int i = n - 1; i >= 1; i--) {
    ll tmp = yakusu(n - i);
    res += tmp;
  }
  cout << res << endl;
}

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;

using ll = long long;
const int INF = 1001001001;
const ll LLINF = 1001001001001001001;
const int MOD = 1000000007;

#define rep(i, n) for (int i = 0; i < (n); ++i)

ll yakusu(ll n) {
  ll ret = 0;

  for (ll i = 1; i * i <= n;
       i++) { // ルートnまで試す。i <= sqrt(n) だと、右辺が少数になってメンドイ
    if (n % i == 0) {
      ret++;
      if (n / i != i) { // ルートnが約数の時は、2つpush_backしないように注意
        ret++;
      }
    }
  }
  return ret;
}

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

  ll res = 0;

  vector<ll> u(n + 5, 0);

  for (int i = n - 1; i >= 1; i--) {
    for (int j = i; j < n; j += i) {
      u[i]++;
    }
  }
  rep(i, n) { res += u[i]; }
  cout << res << endl;
}


/**
 *    author:  ritik_0007
 *    created:  just assume some time
 *    college :IIIT Ranchi
 *	  3rd year(5ht sem)
 **/

#include <bits/stdc++.h>
using namespace std;
#define sz(x) (int)(x).size()
#define int long long int
#define loop(i, a, b) for (int i = a; i < b; i++)
#define scan(arr, n)                                                           \\
  for (int i = 0; i < n; ++i)                                                  \\
  cin >> arr[i]
#define vi vector<int>
#define si set<int>
#define pii pair<int, int>
#define sii set<pii>
#define vii vector<pii>
#define mii map<int, int>
#define pb push_back
#define ff first
#define ss second
#define all(aa) aa.begin(), aa.end()
#define rall(a) a.rbegin(), a.end()
#define faster                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL)
// Constants
const int mod = 1000000007; /* 1e9 + 7*/
const int MAXN = 1000005;   /*1e6 +5 */

int spf[1000009]; // stores the smallest prime factor of a number
const int siz = 100001;
vi adj[siz];
int fac[1000001] = {0};
int depth[siz];
int diameter = 0;

void print(vi v) {
  for (auto x : v)
    cout << x << " ";
  cout << endl;
}

// to find diameter of a tree and distance between two nodes in a tree.
// dist between a and b is depth[b] , Initialise depth[a]=0 for each test case.
int dfs(int u, int par) {
  int len = 0;
  for (auto x : adj[u]) {
    if (x != par) {
      depth[x] = depth[u] + 1;
      int cur = 1 + dfs(x, u);
      diameter = max(diameter, cur + len);
      len = max(len, cur);
    }
  }
  return len;
}

void fact() {
  fac[0] = 1;
  for (int i = 1; i <= 1000000; i++)
    fac[i] = (fac[i - 1] % mod * i % mod) % mod;
}
bool prime[1000001];
void SieveOfEratosthenes() {
  // Create a boolean array "prime[0..n]" and initialize
  // all entries it as true. A value in prime[i] will
  // finally be false if i is Not a prime, else true.
  int n = 1000001;
  memset(prime, true, sizeof(prime));

  for (int p = 2; p * p <= n; p++) {
    // If prime[p] is not changed, then it is a prime
    if (prime[p] == true) {
      // Update all multiples of p greater than or
      // equal to the square of it
      // numbers which are multiple of p and are
      // less than p^2 are already been marked.
      for (int i = p * p; i <= n; i += p)
        prime[i] = false;
    }
  }

  // Print all prime numbers
}

// Function to count divisors
int divCount(int n) {
  // sieve method for prime calculation

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

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

// vi v(1000001);

void solve() {
  SieveOfEratosthenes();
  int n;
  cin >> n;
  int ans = 0;
  // v[1]=1;

  // for(int i=2;i<=1000000;i++)
  // {
  // 	if(prime[i])
  // 		 v[i]=2;
  // 	else
  // 	{
  // 		int st=smallestDivisor(i);
  // 		v[i]=v[i/st]+1;
  // 	}
  // }

  // loop(i,1,11)
  // cout<<v[i]<<" ";
  // cout<<endl;
  // for(int i=1;i<=n-1;i++)
  // 	ans+=v[i];
  loop(i, 1, n) { ans += divCount(i); }
  cout << ans << endl;
}

int32_t main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  fact();
  faster;
  int t = 1;
  // cin>>t;
  while (t--)
    solve();

  return 0;
}

/**
 *    author:  ritik_0007
 *    created:  just assume some time
 *    college :IIIT Ranchi
 *	  3rd year(5ht sem)
 **/

#include <bits/stdc++.h>
using namespace std;
#define sz(x) (int)(x).size()
#define int long long int
#define loop(i, a, b) for (int i = a; i < b; i++)
#define scan(arr, n)                                                           \\
  for (int i = 0; i < n; ++i)                                                  \\
  cin >> arr[i]
#define vi vector<int>
#define si set<int>
#define pii pair<int, int>
#define sii set<pii>
#define vii vector<pii>
#define mii map<int, int>
#define pb push_back
#define ff first
#define ss second
#define all(aa) aa.begin(), aa.end()
#define rall(a) a.rbegin(), a.end()
#define faster                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL)
// Constants
const int mod = 1000000007; /* 1e9 + 7*/
const int MAXN = 1000005;   /*1e6 +5 */

int spf[1000009]; // stores the smallest prime factor of a number
const int siz = 100001;
vi adj[siz];
int fac[1000001] = {0};
int depth[siz];
int diameter = 0;

void print(vi v) {
  for (auto x : v)
    cout << x << " ";
  cout << endl;
}

// to find diameter of a tree and distance between two nodes in a tree.
// dist between a and b is depth[b] , Initialise depth[a]=0 for each test case.
int dfs(int u, int par) {
  int len = 0;
  for (auto x : adj[u]) {
    if (x != par) {
      depth[x] = depth[u] + 1;
      int cur = 1 + dfs(x, u);
      diameter = max(diameter, cur + len);
      len = max(len, cur);
    }
  }
  return len;
}

void fact() {
  fac[0] = 1;
  for (int i = 1; i <= 1000000; i++)
    fac[i] = (fac[i - 1] % mod * i % mod) % mod;
}
bool prime[1000001];
void SieveOfEratosthenes() {
  // Create a boolean array "prime[0..n]" and initialize
  // all entries it as true. A value in prime[i] will
  // finally be false if i is Not a prime, else true.
  int n = 1000001;
  memset(prime, true, sizeof(prime));

  for (int p = 2; p * p <= n; p++) {
    // If prime[p] is not changed, then it is a prime
    if (prime[p] == true) {
      // Update all multiples of p greater than or
      // equal to the square of it
      // numbers which are multiple of p and are
      // less than p^2 are already been marked.
      for (int i = p * p; i <= n; i += p)
        prime[i] = false;
    }
  }

  // Print all prime numbers
}

// Function to count divisors

const int MAX = 1000001;

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

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

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

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

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

// function to calculate number of factors
int calculateNoOFactors(int n) {
  if (n == 1)
    return 1;

  int ans = 1;

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

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

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

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

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

    // prime factorizes a number
    j = j / factor[j];
  }

  // for the last prime factor
  ans = ans * (c + 1);

  return ans;
}

//	vi v(1000001);

void solve() {
  generatePrimeFactors();
  int n;
  cin >> n;
  int ans = 0;
  // v[1]=1;

  // for(int i=2;i<=1000000;i++)
  // {
  // 	if(prime[i])
  // 		 v[i]=2;
  // 	else
  // 	{
  // 		int st=maxPrimeFactors(i);
  // 		v[i]=v[st]+v[i/st];
  // 	}
  // }

  // loop(i,1,11)
  // cout<<v[i]<<" ";
  // cout<<endl;
  for (int i = 1; i <= n - 1; i++) {
    ans += calculateNoOFactors(i);
  }

  cout << ans << endl;
}

int32_t main() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  fact();
  faster;
  int t = 1;
  // cin>>t;
  while (t--)
    solve();

  return 0;
}