#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define REP(i, a, b) for (inti = a; i <= b; i++)

#define MOD 1000000007
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int, int> pi;

ll divisor(ll n) {
  ll ans = 0;
  ll x = (ll)sqrt(n);
  for (ll index = 1; index <= x; index++)
    if (n % index == 0)
      ans += 2;
  if (x && x * x == n)
    ans--;

  // cout<<n<<" "<<ans<<endl;
  return ans;
}
int main() {
  std::ios::sync_with_stdio(false);
  cin.tie(0);
  ll n;
  cin >> n;

  ll ans = 0;
  vector<int> v(n, 0);
  for (ll c = 1; c <= n; c++) {
    if (((n - c) % 2 == 0) && v[(n - c) / 2])
      ans += v[(n - c) / 2] + 2;
    else {
      v[n - c] = divisor(n - c);
      ans += v[n - c];
    }
  }
  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define REP(i, a, b) for (inti = a; i <= b; i++)

#define MOD 1000000007
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int, int> pi;

int main() {
  std::ios::sync_with_stdio(false);
  cin.tie(0);
  ll n;
  cin >> n;

  vector<ll> v(n + 1, 1);
  for (ll index = 2; index <= n; index++) {
    for (ll j = index; j <= n; j += index)
      v[j]++;
  }

  v[0] = 0;
  ll ans = 0;

  for (int c = 1; c < n; c++) {
    ans += v[n - c];
  }

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


#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\\n'
#define co(ans) cout << ans << endl
#define COYE cout << "YES" << endl
#define COYe cout << "Yes" << endl
#define COye cout << "yes" << endl
#define CONO cout << "NO" << endl
#define CONo cout << "No" << endl
#define COno cout << "no" << endl
#define FORE(i, a) for (auto &i : a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FFOR(i, 1, n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort((V).begin(), (V).end())
#define REVERSE(V) reverse((V).begin(), (V).end())
#define EACH(V, i)                                                             \\
  for (typeof((V).begin()) i = (V).begin(); i != (V).end(); ++i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define INF ((1LL << 62) - (1LL << 31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MMOD 998244353
#define MAX 2010101
using namespace std;
using Edge = pair<ll, ll>;
using Graph = vector<vector<int>>;
inline int toInt(string s) {
  int v;
  istringstream sin(s);
  sin >> v;
  return v;
}
template <class T> inline string toString(T x) {
  ostringstream sout;
  sout << x;
  return sout.str();
}
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef long long LL;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }

////////// 約数列挙 //////////

vector<ll> divs[MAX];
// divs[i]=iの約数の集合

void DIVS_init() {
  for (int i = 1; i < MAX; ++i) {
    for (int j = i; j < MAX; j += i) {
      divs[j].push_back(i);
    }
  }
}

//////////////////////////////////////////////////

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

  RREP(i, N - 1) { ans += divs[i].size(); }

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

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\\n'
#define co(ans) cout << ans << endl
#define COYE cout << "YES" << endl
#define COYe cout << "Yes" << endl
#define COye cout << "yes" << endl
#define CONO cout << "NO" << endl
#define CONo cout << "No" << endl
#define COno cout << "no" << endl
#define FORE(i, a) for (auto &i : a)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) FFOR(i, 1, n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort((V).begin(), (V).end())
#define REVERSE(V) reverse((V).begin(), (V).end())
#define EACH(V, i)                                                             \\
  for (typeof((V).begin()) i = (V).begin(); i != (V).end(); ++i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define INF ((1LL << 62) - (1LL << 31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MMOD 998244353
#define MAX 2010101
using namespace std;
using Edge = pair<ll, ll>;
using Graph = vector<vector<int>>;
inline int toInt(string s) {
  int v;
  istringstream sin(s);
  sin >> v;
  return v;
}
template <class T> inline string toString(T x) {
  ostringstream sout;
  sout << x;
  return sout.str();
}
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
typedef long long LL;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }

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

  RREP(i, N) ans += N / i;
  RREP(i, N) if (N % i == 0) cnt++;

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


#include <bits/stdc++.h>
using namespace std;
#define sz long long
#define lld long double
#define pii pair<sz, sz>
#define MOD 1000000007
void SieveOfEratosthenes(sz n, bool prime[], bool primesquare[], sz a[]) {
  // Create a boolean array "prime[0..n]" and
  // initialize all entries it as true. A value
  // in prime[i] will finally be false if i is
  // Not a prime, else true.
  for (sz i = 2; i <= n; i++)
    prime[i] = true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return ans; // Total divisors
}
void solve() {
  sz n;
  cin >> n;
  sz cnt = 0;
  for (sz i = 1; i < n; i++) {
    cnt += countDivisors(n - i);
  }
  cout << cnt << endl;
}
int main() {
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  sz t = 1;
  // cin>>t;
  while (t-- > 0) {
    solve();
  }
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lld long double
#define pii pair<int, int>
#define MOD 1000000007

void solve() {
  ll n;
  cin >> n;
  ll cnt = 0;
  for (ll i = 1; i < n; i++) {
    cnt += (n - 1) / i;
  }
  cout << cnt << endl;
}
int main() {
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int t = 1;
  // cin>>t;
  while (t-- > 0) {
    solve();
  }
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define ld long double
#define pb push_back
#define mp make_pair
#define fi(i, start, end) for (int i = start; i < end; ++i)
#define Fastio                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);
// #define mod 1000000007

using namespace std;

int main() {
  long long unsigned int n;
  cin >> n;
  if (n == 2) {
    return 1;
  }
  long long unsigned int ans = 0;
  for (long long unsigned int a = 1; a < sqrt(n - 1); a++) {
    for (long long unsigned int b = a; a * b < n; b++) {
      ans++;
    }
  }
  ans = ans * 2;

  ans = ans - int(sqrt(n - 1));
  cout << ans;
}

#include <bits/stdc++.h>
using namespace std;
#define ld long double
#define pb push_back
#define mp make_pair
#define fi(i, start, end) for (int i = start; i < end; ++i)
#define Fastio                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);
// #define mod 1000000007

using namespace std;

int main() {
  long long unsigned int n;
  cin >> n;
  if (n == 2) {
    cout << 1;
    return 0;
  }
  long long unsigned int ans = 0;
  for (long long unsigned int a = 1; a < sqrt(n - 1); a++) {
    for (long long unsigned int b = a; a * b < n; b++) {
      ans++;
    }
  }
  ans = ans * 2;

  ans = ans - int(sqrt(n - 1));
  cout << ans;
}


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

int main() {
  int n;
  scanf("%d", &n);
  int cnt = 0;
  for (int i = 1; i <= n - 1; i++) {
    for (int k = 2; k <= sqrt(i); k++) {
      if (i % k == 0) {
        cnt = (k == i / k) ? cnt + 1 : cnt + 2;
      }
    }
  }
  printf("%d\\n", cnt + (2 * (n - 1)) - 1);
  return 0;
}

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

int main() {
  int n;
  scanf("%d", &n);
  int cnt = 0;
  for (int i = 1; i <= n / 2; i++) {
    int tmp = 2 * ((n - 1) / i) - ((i * 2) - 1);
    cnt += (tmp < 0) ? 0 : tmp;
  }
  printf("%d\\n", cnt);
  return 0;
}


//-- In the name of ALLAH --
// We're nothing and you're everything.
// Ya Ali!
#include <bits/stdc++.h>
using namespace std;

#define pai acos(-1)
#define ff first
#define ss second
#define ll long long
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
#define sz(a) (ll) a.size()
#define endl "\\n"
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b))
#define all(vec) vec.begin(), vec.end()
#define ms(a, b) memset(a, b, sizeof(a))
#define TEST_CASE(t) for (int zz = 1; zz <= t; zz++)
#define PRINT_CASE printf("Case %d: ", zz)
#define fii freopen("input.txt", "r", stdin);
#define foo freopen("output.txt", "w", stdout);
#define FAST                                                                   \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);

const ll M = 1e9 + 7;
const ll mxn = 1e6 + 5;

int main() {
  FAST;
  ll i, j, k, a, b, c, d, n, m, t, x, y, z, u, v;
  cin >> n;
  ll cnt = 0;
  for (i = 1; i < n; i++) {
    for (j = 1; j * j <= i; j++) {
      if (i % j == 0) {
        cnt++;
        if (i / j != j) {
          cnt++;
        }
        // cout<<i<<" "<<cnt<<endl;
      }
    }
  }
  cout << cnt << endl;
  return 0;
}

//-- In the name of ALLAH --
// We're nothing and you're everything.
// Ya Ali!
#include <bits/stdc++.h>
using namespace std;

#define pai acos(-1)
#define ff first
#define ss second
#define ll long long
#define pb push_back
#define mp make_pair
#define pll pair<ll, ll>
#define sz(a) (ll) a.size()
#define endl "\\n"
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b)        ((a)*((b)/gcd(a,b))
#define all(vec) vec.begin(), vec.end()
#define ms(a, b) memset(a, b, sizeof(a))
#define TEST_CASE(t) for (int zz = 1; zz <= t; zz++)
#define PRINT_CASE printf("Case %d: ", zz)
#define fii freopen("input.txt", "r", stdin);
#define foo freopen("output.txt", "w", stdout);
#define FAST                                                                   \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);

const ll M = 1e9 + 7;
const ll mxn = 1e6 + 5;

int main() {
  FAST;
  ll i, j, k, a, b, c, d, n, m, t, x, y, z, u, v;
  cin >> n;
  ll cnt = 0;
  for (i = 1; i < n; i++) {
    for (j = 1; i * j < n; j++) {
      cnt++;
    }
  }
  cout << cnt << endl;
  return 0;
}


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

using namespace std;
typedef long long ll;

long long divisor(long long n) {
  ll ret = 0;
  for (long long i = 1; i <= n; i++) {
    if (n % i == 0) {
      ret++;
    }
  }
  return ret;
}

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

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

using namespace std;
typedef long long ll;

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

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


#include <bits/stdc++.h>
using namespace std;
#define int int64_t
#define double long double
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define vii vector<pii>
const int MOD = 1e9 + 7;
const int INF = 1e18;
void io(string s = "file") {
  freopen((s + ".in").c_str(), "r", stdin);
  freopen((s + ".out").c_str(), "w", stdout);
}

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

  int cnt = 0;
  for (int ab = 1; ab <= n; ab++) {
    int c = n - ab;
    if (c <= 0)
      continue;
    for (int a = 1; a * a <= ab; a++) {
      if (ab % a != 0)
        continue;
      int b = ab / a;
      if (a != b)
        cnt += 2;
      else
        cnt++;
    }
  }
  cout << cnt;
}

#include <bits/stdc++.h>
using namespace std;
#define int int64_t
#define double long double
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define vii vector<pii>
const int MOD = 1e9 + 7;
const int INF = 1e18;
void io(string s = "file") {
  freopen((s + ".in").c_str(), "r", stdin);
  freopen((s + ".out").c_str(), "w", stdout);
}

int f[1000001];

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

  for (int i = 1; i <= n; i++) {
    for (int j = i; j <= n; j += i) {
      f[j]++;
    }
  }

  int cnt = 0;
  for (int ab = 1; ab <= n; ab++) {
    int c = n - ab;
    if (c <= 0)
      continue;
    cnt += f[ab];
  }
  cout << cnt;
}


#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 10;
long long n;
pair<long long, long long> a[N];
long long f[N];
string s;
void solve() {
  cin >> n;
  long long ans = 0, q = 0, k = 0;
  memset(f, 0, sizeof f);
  f[1] = 1;
  for (long long i = 2; i <= 1000001; i++) {
    for (long long j = 1; j <= sqrt(i); j++) {
      if (i % j == 0)
        f[i]++;
    }
  }
  ans += f[1];
  for (long long i = 2; i <= n - 1; i++) {
    ans += f[i] * 2;
    k = sqrt(i);
    if (k * k == i)
      ans--;
  }
  cout << ans << endl;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  long long t = 1;
  // cin>>t;
  while (t--) {
    solve();
  }
}

#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 10;
long long n;
void solve() {
  cin >> n;
  long long f[n + 1], ans = 0;
  for (long long i = 1; i <= n; i++)
    f[i] = 0;
  for (long long i = 1; i <= n; i++) {
    for (long long j = i; j <= n; j += i) {
      f[j]++;
    }
  }
  for (long long i = 1; i < n; i++)
    ans += f[i];
  cout << ans << endl;
}
int main() {
  long long t = 1;
  // cin>>t;
  while (t--) {
    solve();
  }
}


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

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

  int ans = 0;
  for (int c = 1; c < n; c++) {
    for (int b = 1; b <= n - c; b++) {
      if ((n - c) % b == 0) {
        ans++;
      }
    }
  }

  cout << ans;
}

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

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

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

  cout << ans;
}


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

int main(void) {
  long long N, X, M;
  cin >> N >> X >> M;

  vector<long long> A(2 * M + 1);
  A[1] = X;
  for (int i = 1; i < 2 * M; i++) {
    A[i + 1] = A[i] * A[i] % M;
  }

  long long ans = 0;
  if (N <= 2 * M) {
    for (int i = 1; i <= N; i++) {
      ans += A[i];
    }
    cout << ans << endl;
    return 0;
  }

  long long cycle = 0, sum = 0, start = 0;
  for (int i = 2 * M - 1; i >= M; i--) {
    if (A[i] == A[2 * M]) {
      cycle = 2 * M - i;
      start = i + 1;
      for (int j = i; j < 2 * M; j++) {
        sum += A[j];
      }
      break;
    }
  }

  for (int i = 1; i <= 2 * M; i++) {
    ans += A[i];
  }
  ans += sum * ((N - 2 * M) / cycle);
  long long d = (N - 2 * M) % cycle;
  for (int i = start; i < start + d; i++) {
    ans += A[i];
  }

  cout << ans << endl;

  return 0;
}

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

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

long long is_divide(long long n) {
  const auto &pf = prime_factorize(n);
  long long res = 1;
  for (auto p : pf)
    res *= p.second + 1;

  return res;
}

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

  long long ans = 0;

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

  cout << ans << endl;

  return 0;
}

terminate called after throwing an instance of 'std::bad_alloc'
  what():  std::bad_alloc


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

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

// cout << fixed << setprecision(15) <<  << endl;


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

int F[2000010];
int factor(int N) {
  if (F[N] != -1)
    return F[N];
  set<pair<int, int>> D;
  for (int i = 1; i * i <= N; i++) {
    if (N % i == 0) {
      D.insert({i, N / i});
      D.insert({N / i, i});
    }
  }
  F[N] = D.size();
  return D.size();
}

int main() {
  rep(i, 2000010) F[i] = -1;
  int N;
  cin >> N;
  ll cnt = 0;
  for (int i = 1; i < N; i++) {
    int C = N - i;
    int D = factor(C);
    cnt += D;
  }
  cout << cnt << endl;
}

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

int factor(int N) {
  int c = 0;
  for (int i = 1; i * i <= N; i++) {
    if (N % i == 0) {
      if (i == N / i)
        c++;
      else
        c += 2;
    }
  }
  return c;
}

int main() {
  int N;
  cin >> N;
  ll cnt = 0;
  for (int i = 1; i < N; i++) {
    int C = N - i;
    int D = factor(C);
    cnt += D;
  }
  cout << cnt << endl;
}


#include <iostream>
#include <vector>
typedef long long ll;
const ll mod = 1000000007;
using namespace std;

int main() {
  int N, cnt = 0;
  cin >> N;
  for (int i = 1; i < N; i++) {
    int box = N - i;
    if (box <= 0)
      break;
    for (int j = 1; j < N; j++) {
      for (int k = 1; k < N; k++) {
        if (j * k == box) {
          cnt++;
          break;
        }
      }
    }
  }
  cout << cnt;
}

#include <iostream>
#include <vector>
typedef long long ll;
const ll mod = 1000000007;
using namespace std;

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

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

  for (int i = 1; i < N; i++) {
    ll box = N - i;
    const auto &pf = prime_factorize(box);
    long long res = 1;
    for (auto p : pf)
      res *= p.second + 1;
    ans += res;
  }
  cout << ans;
}


#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define ll long long int
#define ull unsigned long long
#define si set<ll>
#define vi vector<ll>
#define popcount(x) __builtin_popcountll(x)
#define mii map<ll, ll>
#define vpi vector<pair<ll, ll>>
#define sz(c) (ll) c.size()
#define fr first
#define fastio                                                                 \\
  ios::sync_with_stdio(false);                                                 \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define sc second
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define mem0(a) memset(a, 0, sizeof(a))
#define rep(i, a, n) for (ll i = a; i < n; i++)
#define ld long double
const ll INF = __LONG_LONG_MAX__;
#define rall(a) (a).rbegin(), (a).rend()
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")

ll power(ll b, ll e, ll m) {
  if (b == 0)
    return 0;
  if (e == 0)
    return 1;
  if (e & 1)
    return b * power(b * b % m, e / 2, m) % m;
  return power(b * b % m, e / 2, m);
}
ll power(ll b, ll e) {
  if (b == 0)
    return 0;
  if (e == 0)
    return 1;
  if (e & 1)
    return b * power(b * b, e / 2);
  return power(b * b, e / 2);
}
bool isPowerOfTwo(ll x) {
  // x will check if x == 0 and !(x & (x - 1)) will check if x is a power of 2
  // or not
  return (x && !(x & (x - 1)));
}

ll calc(ll x) {
  ll ans = 0;
  for (int i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      if ((x / i) != i)
        ans += 2;
      else
        ans += 1;
    }
  }
  return ans;
}

void solve() {
  ll n;
  cin >> n;
  ll ans = 0;
  for (ll i = 1; i < n; i++) {
    ll x = n - i;
    ans += calc(x);
  }
  cout << ans;
}

int main() {
  fastio ll tt = 1;
  // cin>>tt;
  while (tt--) {
    solve();
    cout << "\\n";
  }
}

#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define ll long long int
#define ull unsigned long long
#define si set<ll>
#define vi vector<ll>
#define popcount(x) __builtin_popcountll(x)
#define mii map<ll, ll>
#define vpi vector<pair<ll, ll>>
#define sz(c) (ll) c.size()
#define fr first
#define fastio                                                                 \\
  ios::sync_with_stdio(false);                                                 \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define sc second
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define mem0(a) memset(a, 0, sizeof(a))
#define rep(i, a, n) for (ll i = a; i < n; i++)
#define ld long double
const ll INF = __LONG_LONG_MAX__;
#define rall(a) (a).rbegin(), (a).rend()
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")

ll power(ll b, ll e, ll m) {
  if (b == 0)
    return 0;
  if (e == 0)
    return 1;
  if (e & 1)
    return b * power(b * b % m, e / 2, m) % m;
  return power(b * b % m, e / 2, m);
}
ll power(ll b, ll e) {
  if (b == 0)
    return 0;
  if (e == 0)
    return 1;
  if (e & 1)
    return b * power(b * b, e / 2);
  return power(b * b, e / 2);
}
bool isPowerOfTwo(ll x) {
  // x will check if x == 0 and !(x & (x - 1)) will check if x is a power of 2
  // or not
  return (x && !(x & (x - 1)));
}

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;
}

ll calc(ll x) {
  ll ans = 0;
  for (int i = 1; i * i <= x; i++) {
    if (x % i == 0) {
      if ((x / i) != i)
        ans += 2;
      else
        ans += 1;
    }
  }
  return ans;
}

void solve() {
  fastio generatePrimeFactors();
  ll n;
  cin >> n;
  ll ans = 0;
  for (ll i = 1; i < n; i++) {
    ll x = n - i;
    ans += calculateNoOFactors(x);
  }
  cout << ans;
}

int main() {
  fastio ll tt = 1;
  // cin>>tt;
  while (tt--) {
    solve();
    cout << "\\n";
  }
}


#include <bits/stdc++.h>
using namespace std;
#define fastio                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL)

long long num_of_divisors(long long n) {
  long long ara[500], count = 0, i, v;
  for (i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ara[count] = i;
      count++;
    }
  }
  if (n / ara[count - 1] == ara[count - 1])
    v = 2 * count - 1;
  else
    v = 2 * count;
  return v;
}

int main() {
  fastio;
  long long n, i, sum = 1;
  static long long a[1000003];
  cin >> n;
  for (i = 2; i < n; i++) {
    a[i] = num_of_divisors(i);
    sum = sum + a[i];
  }
  cout << sum;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define fastio                                                                 \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL)

int main() {
  fastio;
  long long n, i, j, sum = 0;
  cin >> n;
  for (i = 1; i < n; i++) {
    for (j = 1; i * j < n; j++)
      sum++;
  }
  cout << sum << "\\n";
  return 0;
}


#include <bits/stdc++.h>
#include <stdio.h>
#include <string.h>
using namespace std;
#define ll long long
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, t, n) for (int i = t; i < n; i++)
#define nd "\\n"
using namespace __gnu_pbds;

#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>

/*ll power(ll x,ll t){
if(t<=0){
    return 1;
}
ll y=(power(x,t/2));
y=(y*y)%ma;
if(t%2)
    y=(y*x)%ma;
return y;

}*/
/*ll ph[100001];
void E_phi(int n){

ph[0]=0;
ph[1]=1;
for(int i=2;i<=n;i++){
    ph[i]=i;
}
for(int i=2;i<=n;i++){
    if(ph[i]==i){
        for(int j=i;j<=n;j+=){
            ph[j]-=ph[j]/i;
        }
    }
}

}*/
/*string s,t;
vector<int>  z_fun(string s){

int n = (int) s.length();
    vector<int> z(n);
    for (int i = 1, l = 0, r = 0; i < n; ++i) {
        if (i <= r)
            z[i] = min (r - i + 1, z[i - l]);
        while (i + z[i] < n && s[z[i]] == s[i + z[i]])
            ++z[i];
        if (i + z[i] - 1 > r)
            l = i, r = i + z[i] - 1;
    }
    return z;
}*/

/*struct st{
ll sum,pre,suf,ans;
st(){}
st(ll k){
ans=k,pre=k,suf=k,sum=0;
}

};
ll t[4*200001+4];
ll a[200001];
ll lazy[4*200001+4];
ll mx=1e14;

void push(int ind){
int l=2*ind+1,r=2*ind+2;
t[l]+=lazy[ind];
t[r]+=lazy[ind];
lazy[l]+=lazy[ind];
lazy[r]+=lazy[ind];
lazy[ind]=0;

}

void build(int ind,int l,int r){
if(l==r){
    t[ind]=a[l];
return;
}
int mid=(l+r)/2;
build(2*ind+1,l,mid);
build(2*ind+2,mid+1,r);

  t[ind] =min(t[ind*2+1] , t[ind*2+2]);

}
ll query(int ind,int l,int r,int p,int q){

if(l>q || r<p )
    return mx;
    int mid=(l+r)/2;

if(l>=p && r<=q )
    {
      return t[ind];
    }
    push(ind);
ll x=query(2*ind+1,l,mid,p,q);
ll y=query(2*ind+2,mid+1,r,p,q);

return min(x,y);
}

void update(int ind,int l,int r,int p,int q,int val){
if(l>q || r<p )
    return;

if(l>=p && r<=q )
    {
      t[ind]+=val;
      lazy[ind]+=val;
      return;
    }
push(ind);
int mid=(l+r)/2;
    update(2*ind+1,l,mid,p,q,val);
     update(2*ind+2,mid+1,r,p,q,val);
    t[ind]=min(t[2*ind+1],t[2*ind+2]);

}

ll mod(ll a){
if(a>=0)
    return a;
else return -a;
}
*/

int v[1000001];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  vector<ll> b;
  for (ll i = 0; i < 1000001; i++) {
    if (!v[i]) {
      b.pb(i);
      for (ll j = i * i; j <= 1000000; j++)
        v[j] = 1;
    }
  }

  int n;
  cin >> n;
  ll ans = 1;
  for (int i = 2; i < n; i++) {
    int p = i;
    ll t = 1;
    for (int j = 0; j < b.size() && b[j] * b[j] <= p; j++) {
      int co = 0;
      while (p % b[j] == 0) {
        p /= b[j];
        co++;
      }
      t *= (co + 1);
    }
    if (p > 1)
      t *= 2;
    ans += t;
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
#include <stdio.h>
#include <string.h>
using namespace std;
#define ll long long
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pii pair<ll, ll>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, t, n) for (int i = t; i < n; i++)
#define nd "\\n"
using namespace __gnu_pbds;

#define ordered_set                                                            \\
  tree<int, null_type, less<int>, rb_tree_tag,                                 \\
       tree_order_statistics_node_update>

/*ll power(ll x,ll t){
if(t<=0){
    return 1;
}
ll y=(power(x,t/2));
y=(y*y)%ma;
if(t%2)
    y=(y*x)%ma;
return y;

}*/
/*ll ph[100001];
void E_phi(int n){

ph[0]=0;
ph[1]=1;
for(int i=2;i<=n;i++){
    ph[i]=i;
}
for(int i=2;i<=n;i++){
    if(ph[i]==i){
        for(int j=i;j<=n;j+=){
            ph[j]-=ph[j]/i;
        }
    }
}

}*/
/*string s,t;
vector<int>  z_fun(string s){

int n = (int) s.length();
    vector<int> z(n);
    for (int i = 1, l = 0, r = 0; i < n; ++i) {
        if (i <= r)
            z[i] = min (r - i + 1, z[i - l]);
        while (i + z[i] < n && s[z[i]] == s[i + z[i]])
            ++z[i];
        if (i + z[i] - 1 > r)
            l = i, r = i + z[i] - 1;
    }
    return z;
}*/

/*struct st{
ll sum,pre,suf,ans;
st(){}
st(ll k){
ans=k,pre=k,suf=k,sum=0;
}

};
ll t[4*200001+4];
ll a[200001];
ll lazy[4*200001+4];
ll mx=1e14;

void push(int ind){
int l=2*ind+1,r=2*ind+2;
t[l]+=lazy[ind];
t[r]+=lazy[ind];
lazy[l]+=lazy[ind];
lazy[r]+=lazy[ind];
lazy[ind]=0;

}

void build(int ind,int l,int r){
if(l==r){
    t[ind]=a[l];
return;
}
int mid=(l+r)/2;
build(2*ind+1,l,mid);
build(2*ind+2,mid+1,r);

  t[ind] =min(t[ind*2+1] , t[ind*2+2]);

}
ll query(int ind,int l,int r,int p,int q){

if(l>q || r<p )
    return mx;
    int mid=(l+r)/2;

if(l>=p && r<=q )
    {
      return t[ind];
    }
    push(ind);
ll x=query(2*ind+1,l,mid,p,q);
ll y=query(2*ind+2,mid+1,r,p,q);

return min(x,y);
}

void update(int ind,int l,int r,int p,int q,int val){
if(l>q || r<p )
    return;

if(l>=p && r<=q )
    {
      t[ind]+=val;
      lazy[ind]+=val;
      return;
    }
push(ind);
int mid=(l+r)/2;
    update(2*ind+1,l,mid,p,q,val);
     update(2*ind+2,mid+1,r,p,q,val);
    t[ind]=min(t[2*ind+1],t[2*ind+2]);

}

ll mod(ll a){
if(a>=0)
    return a;
else return -a;
}
*/

int v[1000001];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  vector<ll> b;
  for (ll i = 2; i < 1000001; i++) {
    if (!v[i]) {
      b.pb(i);
      for (ll j = i * i; j <= 1000000; j += i)
        v[j] = 1;
    }
  }

  int n;
  cin >> n;
  ll ans = 1;
  for (int i = 2; i < n; i++) {
    int p = i;
    ll t = 1;
    for (int j = 0; j < b.size() && b[j] * b[j] <= p; j++) {
      int co = 0;
      while (p % b[j] == 0) {
        p /= b[j];
        co++;
      }
      t *= (co + 1);
    }
    if (p > 1)
      t *= 2;
    ans += t;
  }
  cout << ans << endl;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
  int n, ans = 0;
  scanf("%d", &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)
          ans++;
      }
    }
  }
  printf("%d\\n", ans);
}

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


#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n, m) for (int i = (n); i >= (m); --i)
using namespace std;
using LL = long long;
using LD = long double;
using PLL = pair<long long, long long>;
using PLD = pair<long double, long double>;
using VLL = vector<long long>;
using VLD = vector<long double>;
using VPLL = vector<PLL>;
using VPLD = vector<PLD>;

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

int main() {

  int n;
  cin >> n;

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

  cout << ans << endl;

  return 0;
}

#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n, m) for (int i = (n); i >= (m); --i)
using namespace std;
using LL = long long;
using LD = long double;
using PLL = pair<long long, long long>;
using PLD = pair<long double, long double>;
using VLL = vector<long long>;
using VLD = vector<long double>;
using VPLL = vector<PLL>;
using VPLD = vector<PLD>;

int main() {

  int n;
  cin >> n;

  int ans = 0;

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

  cout << ans << endl;

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

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

  int n, ans = 0;
  cin >> n;
  for (int c = 1; c < n; c++) {
    int d = n - c;
    for (int j = 1; j * j <= d; j++) {
      if (d % j == 0) {
        ans++;
        if (d / j != j)
          ans++;
      }
    }
  }
  cout << ans << endl;

  return 0;
}

#include <bits/stdc++.h>
#define MAXN 1000001

using namespace std;

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

  int n, ans = 0;
  cin >> n;
  vector<int> prime(MAXN, 0);
  for (int i = 2; i * i < MAXN; i++) {
    if (!prime[i])
      for (int j = i * i; j < MAXN; j += i)
        prime[j] = i;
  }
  for (int i = 2; i < MAXN; i++)
    if (!prime[i])
      prime[i] = i;
  for (int c = 1; c < n; c++) {
    int d = n - c, res = 1;
    while (d > 1) {
      int div = prime[d], cnt = 0;
      while (d % div == 0) {
        cnt++;
        d /= div;
      }
      res = res * (cnt + 1);
    }
    ans += res;
  }
  cout << ans << endl;

  return 0;
}


#include <bits/stdc++.h>

using namespace std;

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

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

int main() {
  int n;
  cin >> n;
  int cnt = 0;
  vector<int> v;
  int i = 1;
  int j = n;

  while (i <= j) {
    if (i + j == n) {
      if (i == j) {
        v.push_back(i);
      } else {
        v.push_back(i);
        v.push_back(j);
      }

      i++;
      j--;
    } else if (i + j > n) {
      j--;
    } else {
      i++;
    }
  }

  for (int i = 0; i < v.size(); i++) {
    cnt = cnt + countDivisors(v[i]);
  }

  cout << cnt;
}

#include <bits/stdc++.h>

using namespace std;

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

      else // Otherwise count both
        cnt = cnt + 2;
    }
  }
  return cnt;
}
#define N 100005

int dp[10 * N];

void solve() {
  for (int i = 1; i <= 10 * N; i++) {
    for (int j = 1; j * i <= 10 * N; j++) {
      dp[j * i]++;
    }
  }
}

int main() {
  int n;
  cin >> n;
  int cnt = 0;
  // vector<int> v;
  // int i=1;
  // int j=n;

  // while(i<=j)
  // {
  //     if(i+j == n)
  //     {
  //         if(i==j)
  //         {
  //             v.push_back(i);
  //         }
  //         else
  //         {
  //             v.push_back(i);
  //             v.push_back(j);
  //         }

  //         i++;
  //         j--;
  //     }
  //     else if(i+j>n)
  //     {
  //         j--;
  //     }
  //     else
  //     {
  //         i++;
  //     }

  // }
  solve();

  for (int i = 1; i < n; i++) {
    cnt = dp[i] + cnt;
  }

  cout << cnt;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, s, n) for (int i = s; i < n; i++)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
using Graph = vector<vector<int>>;
const int INF = 1000000007;
int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  ll tmp, j;
  REP(i, 1, n) {
    tmp = n - i;
    for (j = 1; j * j <= tmp; j++) {
      if (tmp % j == 0) {
        if (j == sqrt(tmp))
          ans++;
        else
          ans += 2;
      }
    }
  }

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

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, s, n) for (int i = s; i < n; i++)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
using Graph = vector<vector<int>>;
const int INF = 1000000007;
int main() {
  ll n;
  cin >> n;
  ll ans = 0;
  REP(i, 1, n + 1) { ans += (n - 1) / i; }
  cout << ans << endl;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// typedef tree <int,null_type,less <int>, rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
//  #include <ext/rope>
//  using namespace __gnu_cxx;
typedef long long int ll;
typedef long double ld;
#define FAST                                                                   \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define rep(g, i, n) for (ll g = i; g < n; g++)
#define rev(g, n, i) for (ll g = n - 1; g >= i; g--)
#define all(v) v.begin(), v.end()
#define pb push_back
#define mxe(v) *max_element(v.begin(), v.end())
#define mne(v) *min_element(v.begin(), v.end())
#define ve vector
#define lb lower_bound
#define ub upper_bound
#define bb break
#define cc continue
#define rem 1000000007
#define PI 3.141592653589793238462643383279502
ll power(ll x, ll y, ll p) {
  ll res = 1; // Initialize result
  x = x % p;  // Update x if it is more than or
  while (y > 0) {
    if (y & 1)
      res = (res * x) % p;
    y = y >> 1; // y = y/2
    x = (x * x) % p;
  }
  return res;
}
ll modInverse(ll n, ll p) { return power(n, p - 2, p); }
struct point {
  ll x, y;
};
int countDivisors(int n) {
  int cnt = 0;
  for (int i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      // If divisors are equal,
      // count only one
      if (n / i == i)
        cnt++;

      else // Otherwise count both
        cnt = cnt + 2;
    }
  }
  return cnt;
}
int main() {
  FAST
      // freopen("input1.txt", "r", stdin);
      // freopen("output.txt", "w", stdout);
      /*ll tests;
      cin>>tests;
      rep (gg,0,tests)
      {}*/
      ll n;
  cin >> n;
  ll facs = 0, ans = 0;
  rep(i, 1, n) {
    ll facs = countDivisors(n - i);
    ans += facs;
  }
  cout << ans << "\\n";
}

#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// typedef tree <int,null_type,less <int>, rb_tree_tag,
// tree_order_statistics_node_update> indexed_set;
//  #include <ext/rope>
//  using namespace __gnu_cxx;
typedef long long int ll;
typedef long double ld;
#define FAST                                                                   \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define rep(g, i, n) for (ll g = i; g < n; g++)
#define rev(g, n, i) for (ll g = n - 1; g >= i; g--)
#define all(v) v.begin(), v.end()
#define pb push_back
#define mxe(v) *max_element(v.begin(), v.end())
#define mne(v) *min_element(v.begin(), v.end())
#define ve vector
#define lb lower_bound
#define ub upper_bound
#define bb break
#define cc continue
#define rem 1000000007
#define PI 3.141592653589793238462643383279502
ll power(ll x, ll y, ll p) {
  ll res = 1; // Initialize result
  x = x % p;  // Update x if it is more than or
  while (y > 0) {
    if (y & 1)
      res = (res * x) % p;
    y = y >> 1; // y = y/2
    x = (x * x) % p;
  }
  return res;
}
ll modInverse(ll n, ll p) { return power(n, p - 2, p); }
struct point {
  ll x, y;
};
int main() {
  FAST
      // freopen("input1.txt", "r", stdin);
      // freopen("output.txt", "w", stdout);
      /*ll tests;
      cin>>tests;
      rep (gg,0,tests)
      {}*/
      ll n;
  cin >> n;
  ll facs = 0, ans = 0;
  rep(i, 1, n + 1) {
    ll facs = n / i;
    if (n % i == 0) {
      facs--;
    }
    ans += facs;
  }
  cout << ans << "\\n";
}


#include <bits/stdc++.h>

using namespace std;

#define tr(c, i)                                                               \\
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define ipr pair<int, int>
#define pb push_back
#define ff first
#define ss second
#define fill(a, b) memset(a, b, sizeof(a))
#define fr(i, j, k) for (int i = j; i < k; i++)
#define rf(i, j, k) for (int i = j; i >= k; i--)
#define int long long int
#define ll unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define mp make_pair
#define L(x) ('a' <= x && x <= 'z')
#define inf INT_MAX
#define read_file()                                                            \\
  ;                                                                            \\
  freopen("input.txt", "r", stdin);                                            \\
  freopen("output.txt", "w", stdout);
#define IOS                                                                    \\
  std::ios::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);

const int Maxn = 200 * 1000 + 1;
const ld pi = acos(-1);
const int mod = 1000000007;
const double epsilon = 1e-9;

template <class T> ostream &operator<<(ostream &out, vector<T> &A) {
  for (auto x : A)
    out << x << " ";
  return out;
}
template <class T> ostream &operator<<(ostream &out, set<T> &A) {
  for (auto x : A)
    out << x << " ";
  return out;
}
template <class T> ostream &operator<<(ostream &out, unordered_set<T> &A) {
  for (auto x : A)
    out << x << " ";
  return out;
}
template <class T1, class T2> T1 powr(T1 a, T2 b) {
  T1 res = 1;
  fr(i, 1, b + 1) res = res * a;
  return res;
}

int binpow(int a, int b) {
  a = a % mod;

  int res = 1;
  while (b > 0) {
    if (b & 1)
      res = (res * a) % mod;
    a = (a * a) % mod;
    b >>= 1;
  }
  return (res + mod) % mod;
}

int32_t main() {
  IOS;

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

    int n;
    cin >> n;
    int cnt = 0;
    for (int i = 1; i < n; i++) {
      int x = n - i;

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

#include <bits/stdc++.h>

using namespace std;

#define tr(c, i)                                                               \\
  for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define ipr pair<int, int>
#define pb push_back
#define ff first
#define ss second
#define fill(a, b) memset(a, b, sizeof(a))
#define fr(i, j, k) for (int i = j; i < k; i++)
#define rf(i, j, k) for (int i = j; i >= k; i--)
#define int long long int
#define ll unsigned long long
#define ld long double
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define mp make_pair
#define L(x) ('a' <= x && x <= 'z')
#define inf INT_MAX
#define read_file()                                                            \\
  ;                                                                            \\
  freopen("input.txt", "r", stdin);                                            \\
  freopen("output.txt", "w", stdout);
#define IOS                                                                    \\
  std::ios::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);

const ld pi = acos(-1);
const int mod = 1000000007;
const double epsilon = 1e-9;

template <class T> ostream &operator<<(ostream &out, vector<T> &A) {
  for (auto x : A)
    out << x << " ";
  return out;
}
template <class T> ostream &operator<<(ostream &out, set<T> &A) {
  for (auto x : A)
    out << x << " ";
  return out;
}
template <class T> ostream &operator<<(ostream &out, unordered_set<T> &A) {
  for (auto x : A)
    out << x << " ";
  return out;
}
template <class T1, class T2> T1 powr(T1 a, T2 b) {
  T1 res = 1;
  fr(i, 1, b + 1) res = res * a;
  return res;
}

int binpow(int a, int b) {
  a = a % mod;

  int res = 1;
  while (b > 0) {
    if (b & 1)
      res = (res * a) % mod;
    a = (a * a) % mod;
    b >>= 1;
  }
  return (res + mod) % mod;
}

const int MAXN = 1e6 + 1;

int spf[MAXN];

void sieve() {
  spf[1] = 1;
  for (int i = 2; i < MAXN; i++)

    // marking smallest prime factor for every
    // number to be itself.
    spf[i] = i;

  // separately marking spf for every even
  // number as 2
  for (int i = 4; i < MAXN; i += 2)
    spf[i] = 2;

  for (int i = 3; i * i < MAXN; i++) {
    // checking if i is prime
    if (spf[i] == i) {
      // marking SPF for all numbers divisible by i
      for (int j = i * i; j < MAXN; j += i)

        // marking spf[j] if it is not
        // previously marked
        if (spf[j] == j)
          spf[j] = i;
    }
  }
}

int32_t main() {
  IOS;

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

    ll n;
    cin >> n;
    ll sum = 0;
    for (ll i = 1; i <= n; i++) {
      sum += (n / i);
      if (n % i == 0) {
        sum--;
      }
    }
    cout << sum << "\\n";
  }
}


#include <algorithm>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <memory.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<pii, int> p3i;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<p3i> v3i;
typedef vector<vii> vvii;
typedef vector<p3i> vp3i;
typedef long double ld;
typedef vector<ld> vld;

#define pb push_back
#define mp make_pair
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define REPD(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define FORD(i, a, b) for (int(i) = (a); (i) >= (b); (i)--)
#define sz(v) (int)(v).size()
#define all(v) (v).begin(), (v).end()
#define rv(v) reverse(all(v))
#define CL(v, val) memset((v), (val), sizeof((v)))
#define SORT(a) sort(all(a))
#define un(v) SORT(v), (v).resize(unique(all(v)) - (v).begin())
#define eps 1.0e-9
#define X first
#define Y second
#define bit(n) (1 << (n))
#define bit64(n) (ll(1) << (n))
#define sqr(x) ((x) * (x))
#define sq5(x) ((x) * (x) * (x) * (x) * (x))

int main(void) {
  int n;
  scanf("%d", &n);
  ll cnt = 0;

  FOR(i, 1, n) {
    for (int j = 1; j * j <= i; j++) {
      if (i % j == 0) {
        if (j * j == i)
          cnt += 1;
        else
          cnt += 2;
      }
    }
  }

  printf("%lld\\n", cnt);
}

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <memory.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<pii, int> p3i;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<p3i> v3i;
typedef vector<vii> vvii;
typedef vector<p3i> vp3i;
typedef long double ld;
typedef vector<ld> vld;

#define pb push_back
#define mp make_pair
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define REPD(i, n) for (int(i) = (n)-1; (i) >= 0; (i)--)
#define FOR(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define FORD(i, a, b) for (int(i) = (a); (i) >= (b); (i)--)
#define sz(v) (int)(v).size()
#define all(v) (v).begin(), (v).end()
#define rv(v) reverse(all(v))
#define CL(v, val) memset((v), (val), sizeof((v)))
#define SORT(a) sort(all(a))
#define un(v) SORT(v), (v).resize(unique(all(v)) - (v).begin())
#define eps 1.0e-9
#define X first
#define Y second
#define bit(n) (1 << (n))
#define bit64(n) (ll(1) << (n))
#define sqr(x) ((x) * (x))
#define sq5(x) ((x) * (x) * (x) * (x) * (x))

int main(void) {
  int n;
  scanf("%d", &n);
  ll cnt = 0;

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

  printf("%lld\\n", cnt);
}


#include <bits/stdc++.h>
using namespace std;
#define MAX 1000000000005
#define ll long long int
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  ll t;

  long long int m, sum = 0, k = 0, i, j, x = 0, sum1 = 0, l, kk, y, z, e, f,
                   q = MAX, r = MAX, n;
  ll a, b, c = 0, d, zz = 1;
  cin >> n;

  for (i = 0; i < n - 1; i++) {
    c = n - i - 1;
    d = 0;
    e = sqrt(c);
    for (j = 1; j <= sqrt(c); j++) {
      if (c % j == 0)
        d++;
    }
    d *= 2;
    if (e * e == c)
      d--;
    sum += d;
  }
  cout << sum << endl;
}

#include <bits/stdc++.h>
using namespace std;
#define MAX 1000000000005
#define ll long long int
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  ll t;

  long long int m, sum = 0, k = 0, i, j, x = 0, sum1 = 0, l, kk, y, z, e, f,
                   q = MAX, r = MAX, n;
  ll b, c = 0, d, zz = 1;
  cin >> n;
  ll a[1000000] = {1};
  for (i = 2; i <= 1000000; i++) {
    for (j = i; j <= 1000000; j += i)
      a[j]++;
  }
  for (i = 1; i < n; i++)
    sum += a[i] + 1;
  cout << sum << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < (int)(n); i++)
using ll = long long;
using pll = pair<ll, ll>;
using vvll = vector<vector<ll>>;
using vll = vector<ll>;
using vstr = vector<string>;
const ll MOD = 1000000007;
vll dx{0, 1, 0, -1};
vll dy{1, 0, -1, 0};

int main() {
  int N;
  cin >> N;
  int res = 0;
  for (int c = 1; c < N; c++) {
    int ab = N - c;
    for (int a = 1; a * a <= ab; a++) {
      if (ab % a == 0) {
        res++;
        if (ab / a != a) {
          res++;
        }
      }
    }
  }
  cout << res;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < (int)(n); i++)
using ll = long long;
using pll = pair<ll, ll>;
using vvll = vector<vector<ll>>;
using vll = vector<ll>;
using vstr = vector<string>;
const ll MOD = 1000000007;
vll dx{0, 1, 0, -1};
vll dy{1, 0, -1, 0};

void solve() {
  int N;
  cin >> N;
  int res = 0;
  for (int c = 1; c < N; c++) {
    int ab = N - c;
    for (int a = 1; a * a <= ab; a++) {
      if (ab % a == 0) {
        res++;
        if (ab / a != a) {
          res++;
        }
      }
    }
  }
  cout << res << endl;
}

int main() {
  solve();
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < (int)(n); i++)
using ll = long long;
using pll = pair<ll, ll>;
using vvll = vector<vector<ll>>;
using vll = vector<ll>;
using vstr = vector<string>;
const ll MOD = 1000000007;
vll dx{0, 1, 0, -1};
vll dy{1, 0, -1, 0};

int main() {
  ll N;
  cin >> N;
  ll res = 0;
  for (ll c = 1; c < N; c++) {
    ll ab = N - c;
    for (ll a = 1; a * a <= ab; a++) {
      if (ab % a == 0) {
        res++;
        if (ab / a != a) {
          res++;
        }
      }
    }
  }
  cout << res;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 1; i < (int)(n); i++)
using ll = long long;
using pll = pair<ll, ll>;
using vvll = vector<vector<ll>>;
using vll = vector<ll>;
using vstr = vector<string>;
const ll MOD = 1000000007;
vll dx{0, 1, 0, -1};
vll dy{1, 0, -1, 0};

int main() {
  int N;
  cin >> N;
  int res = 0;
  for (int c = 1; c < N; c++) {
    int ab = N - c;
    for (int a = 1; a * a <= ab; a++) {
      if (ab % a == 0) {
        res++;
        if (ab / a != a) {
          res++;
        }
      }
    }
  }
  cout << res;
  return 0;
}


#include <bits/stdc++.h>
#define fastio                                                                 \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define endl "\\n"
#define int long long int
using namespace std;
int mod = 1e9 + 7;

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

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

#include <bits/stdc++.h>
#define fastio                                                                 \\
  ios::sync_with_stdio(0);                                                     \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define endl "\\n"
#define int long long int
using namespace std;
int mod = 1e9 + 7;

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

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


#define DEBUG 0
#include <bits/stdc++.h>
#define all(v) (v).begin(), (v).end()
#define pb push_back
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP2(i, x, n) for (int i = x; i < (n); i++)
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> using numr = std::numeric_limits<T>;
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
const int INF = 1e9;
const ll LLINF = 1e16;
const int mod = 1000000007;
const int mod2 = 998244353;
void debug_impl() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head;
  debug_impl(tail...);
}
#if DEBUG
#define debug(...)                                                             \\
  do {                                                                         \\
    std::cerr << std::boolalpha << "[" << #__VA_ARGS__ << "]:";                \\
    debug_impl(__VA_ARGS__);                                                   \\
    std::cerr << std::noboolalpha;                                             \\
  } while (false)
#else
#define debug(...)                                                             \\
  {}
#endif

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

template <typename Container, typename Value = typename Container::value_type,
          std::enable_if_t<!std::is_same<Container, std::string>::value,
                           std::nullptr_t> = nullptr>
std::ostream &operator<<(std::ostream &os, Container const &v) {
  os << "{";
  for (auto it = v.begin(); it != v.end(); it++) {
    os << (it != v.begin() ? "," : "") << *it;
  }
  return os << "}";
}
vector<int64_t> divisor(int64_t n) {
  vector<int64_t> ret;
  for (int64_t i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

int main() {
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  int n;
  cin >> n;
  int ans = 0;
  for (int a = 1; a < n; a++) {
    ans += divisor(a).size();
  }
  cout << ans << endl;
}

#define DEBUG 0
#include <bits/stdc++.h>
#define all(v) (v).begin(), (v).end()
#define pb push_back
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP2(i, x, n) for (int i = x; i < (n); i++)
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> using numr = std::numeric_limits<T>;
template <class T> bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
const int INF = 1e9;
const ll LLINF = 1e16;
const int mod = 1000000007;
const int mod2 = 998244353;
void debug_impl() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_impl(Head head, Tail... tail) {
  std::cerr << " " << head;
  debug_impl(tail...);
}
#if DEBUG
#define debug(...)                                                             \\
  do {                                                                         \\
    std::cerr << std::boolalpha << "[" << #__VA_ARGS__ << "]:";                \\
    debug_impl(__VA_ARGS__);                                                   \\
    std::cerr << std::noboolalpha;                                             \\
  } while (false)
#else
#define debug(...)                                                             \\
  {}
#endif

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

template <typename Container, typename Value = typename Container::value_type,
          std::enable_if_t<!std::is_same<Container, std::string>::value,
                           std::nullptr_t> = nullptr>
std::ostream &operator<<(std::ostream &os, Container const &v) {
  os << "{";
  for (auto it = v.begin(); it != v.end(); it++) {
    os << (it != v.begin() ? "," : "") << *it;
  }
  return os << "}";
}
vector<int64_t> divisor(int64_t n) {
  vector<int64_t> ret;
  for (int64_t i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

int main() {
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  int n;
  cin >> n;
  int ans = 0;
  for (int a = 1; a <= n; a++) {
    for (int b = 1; a * b < n; b++) {
      ans++;
    }
  }
  cout << ans << endl;
}


#include <iostream>
using namespace std;

int main() {
  int N;
  cin >> N;
  long long count = 0;
  for (int c = 1; c < N; c++) {
    int p = N - c;
    for (long long i = 1; i * i <= p; i++) {
      if (p % i == 0) {
        count++;
        if (i * i != p)
          count++;
      }
    }
  }
  cout << count << endl;
}

#include <iostream>

using namespace std;

int main() {
  int N;
  cin >> N;
  long long count = 0;
  for (int i = 1; i <= N - 1; i++) {
    count += ((N - 1) / i);
  }

  cout << count << endl;
}


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

long long NNN(long long a) {
  long long cnt = 0;
  for (ll i = 1; i * i <= a; i++) {
    if (i * (a / i) == a)
      cnt += 2;
    if (i * i == a)
      cnt--;
  }
  return cnt;
}

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

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

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


#include <bits/stdc++.h>
using namespace std;
#define very_slow                                                              \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define int long long int
int32_t main() {
  very_slow
  //	no_of_test(x)
  {
    int n;
    cin >> n;
    //  int cnt=0;
    map<int, int> mp;
    for (int i = 1; i <= n - 1; i++) {
      for (int j = 1; j <= n - 1; j++) {
        if (i * j <= n - 1) {
          mp[i * j]++;
        }
      }
    }
    int cnt = 0;
    for (auto x : mp) {
      cnt += x.second;
    }
    cout << cnt << '\\n';
  }
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define very_slow                                                              \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define int long long int
int32_t main() {
  very_slow
  //	no_of_test(x)
  {
    int n;
    cin >> n;
    int cnt = 0;
    /* map<int,int>mp;
     for(int i=1;i<=n-1;i++)
     {
             for(int j=1;j<=n-1;j++)
             {
                     if(i*j<=n-1)
                     {
                             mp[i*j]++;
                     }
             }
     }
     int cnt=0;
     for(auto x:mp)
     {
    cnt+=x.second;
     }*/
    int w = 1;
    while (w < n) {
      int r;
      if (n % w == 0) {
        r = (n / w) - 1;
      } else {
        r = (n / w);
      }

      cnt += (r);
      w++;
    }
    int k = sqrt(n);
    cout << cnt << '\\n';
  }
  return 0;
}


#include <cmath>
#include <cstdio>
#include <iostream>

using namespace std;

int main() {
  int n = 0, i = 1, j = 1, k = 1, cnt = 0;

  cin >> n;

  for (i = 1; i < n; i++) {
    for (j = 1; j < n; j++) {
      for (k = 1; k < n; k++) {
        if ((i * j + k) == n) {
          cnt += 1;
        }
      }
    }
  }
  cout << cnt;
}

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>

using namespace std;

int main() {
  int n = 0, i = 1, j = 1, k = 1, cnt = 0;

  cin >> n;

  for (i = 1; i < n; i++) {
    for (j = 1; j < n; j++) {
      k++;
      cnt += 1;
      if (i * j + k > n) {
        break;
      }
    }
    k = 1;
  }
  cout << cnt;
}


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

#define ll long long

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

  ll ans = 0;
  for (int i = 1; i < n; ++i) {
    for (int j = 1; j < n; ++j) {
      for (int k = 1; k <= n - i * j; ++k) {
        if (n - k == i * j)
          ++ans;
      }
    }
  }
  cout << ans << endl;
}

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

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

  int sum = 0;
  for (int i = 1; i < n; ++i) {
    sum += (n - 1) / i;
  }
  cout << sum << "\\n";
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> //PBDS
#include <ext/pb_ds/tree_policy.hpp>     //PBDS
#define int long long int
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pi pair<int, int>
#define deb(x) cerr << #x << " : " << x << endl;
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define mi map<int, int>
#define PI 3.141592653589
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define f(i, x, n) for (int i = x; i < n; i++)
#define rf(i, x, n) for (int i = n - 1; i >= x; i--)
#define check(x) cerr << #x << " : " << x << endl;
#define ordered_set                                                            \\
  tree<int, null_type, less_equal<int>, rb_tree_tag,                           \\
       tree_order_statistics_node_update>
#define fbo find_by_order // return iterator PBDS
#define ook order_of_key  // return number :)) PBDS
#define baar exit(0)
#define INF 1000000000000000000
using namespace __gnu_pbds;
using namespace std;
signed main() {
  fast int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; i++) {
    for (int j = 1; j <= sqrt(i); j++) {
      if (i % j == 0) {
        if (i / j == j)
          ans++;
        else
          ans += 2;
      }
    }
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> //PBDS
#include <ext/pb_ds/tree_policy.hpp>     //PBDS
#define int long long int
#define vi vector<int>
#define vii vector<pair<int, int>>
#define pi pair<int, int>
#define deb(x) cerr << #x << " : " << x << endl;
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define mi map<int, int>
#define PI 3.141592653589
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define f(i, x, n) for (int i = x; i < n; i++)
#define rf(i, x, n) for (int i = n - 1; i >= x; i--)
#define check(x) cerr << #x << " : " << x << endl;
#define ordered_set                                                            \\
  tree<int, null_type, less_equal<int>, rb_tree_tag,                           \\
       tree_order_statistics_node_update>
#define fbo find_by_order // return iterator PBDS
#define ook order_of_key  // return number :)) PBDS
#define baar exit(0)
#define INF 1000000000000000000
using namespace __gnu_pbds;
using namespace std;
signed main() {
  fast int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; i++) {
    int val = n / i;
    ans += val;
    if (n % i == 0)
      ans--;
  }
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n - 1); i >= 0; i--)
#define all(x) x.begin(), x.end()
#define br cout << "\\n";
using namespace std;
const long long INF = 1e10;
const long long MOD = 1e9 + 7;
using Graph = vector<vector<ll>>;
using pll = pair<ll, ll>;
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;
}
ll ceilll(ll a, ll b) { return (a + b - 1) / b; } // if(a%b == 0) (a/b) + 1
ll get_digit(ll a) {
  ll digit = 0;
  while (a != 0) {
    a /= 10;
    digit++;
  }
  return digit;
} // a != 0
template <typename T> void vecdbg(vector<T> &v) {
  rep(i, v.size()) { cout << v[i] << " "; }
  br;
}
template <typename T> void vecvecdbg(vector<vector<T>> &v) {
  rep(i, v.size()) {
    rep(j, v[i].size()) { cout << v[i][j] << " "; }
    br;
  }
}

// 0 false, 1 true
// string number to int : -48
// a to A : -32
// ceil(a)  1.2->2.0
// c++17	g++ -std=c++17 a.cpp
// global vector -> 0 initialization
ll ans = 0;
struct PrimeNumber {
  // O(sqrt(n))
  // sosu hantei
  bool is_prime(long long n) {
    for (long long i = 2; i * i <= n; i++) {
      if (n % i == 0)
        return false;
    }
    return n != 1;
  }

  // O(sqrt(n))  isn't sorted
  // yakusu rekkyo
  void divisor(long long n) {
    // vector<long long> res;
    ll x = 0;
    for (long long i = 1; i * i <= n; i++) {
      if (n % i == 0) {
        // res.push_back(i);
        x++;
        if (i != n / i) {
          // res.push_back(n / i);
          x++;
        }
      }
    }
    if (x % 2 == 0) {
      ans += x;
    } else {
      ans += x / 2 * 2 + 1;
    }
    // return res;
  }

  // O(sqrt(n))
  // soinsu bunkai
  map<long long, long long> prime_factor(long long n) {
    map<long long, long long> res;
    for (long long i = 2; i * i <= n; i++) {
      while (n % i == 0) {
        n /= i;
        res[i]++;
      }
    }
    if (n != 1)
      res[n] = 1;
    return res;
  }

  // O(n log log n)
  // n madeno sosu rekkyo
  vector<long long> eratosthenes(long long n) {
    vector<long long> prime;
    vector<bool> is_prime(n + 1, true);
    long long p = 0;
    is_prime[0] = false;
    is_prime[1] = false;
    for (long long i = 2; i <= n; i++) {
      if (is_prime[i])
        prime.push_back(i);
      for (long long j = 2 * i; j <= n; j += i)
        is_prime[j] = false;
    }
    return prime;
  }
};

int main() {
  std::cout << std::fixed << std::setprecision(15);
  ll n;
  cin >> n;
  PrimeNumber p;
  for (ll c = 1; c <= n - 1; c++) {
    ll tmp = n - c;
    p.divisor(tmp);
    /*
    if(v.size() % 2 == 0){
        ans += v.size();
    }else{
        ans += v.size() / 2 * 2 + 1;
    }
    */
    /*
    cout << "v " << v.size() << endl;
    ans += (v.size() + 1)/ 2;
    cout << ans << endl;
    */
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n - 1); i >= 0; i--)
#define all(x) x.begin(), x.end()
#define br cout << "\\n";
using namespace std;
const long long INF = 1e10;
const long long MOD = 1e9 + 7;
using Graph = vector<vector<ll>>;
using pll = pair<ll, ll>;
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;
}
ll ceilll(ll a, ll b) { return (a + b - 1) / b; } // if(a%b == 0) (a/b) + 1
ll get_digit(ll a) {
  ll digit = 0;
  while (a != 0) {
    a /= 10;
    digit++;
  }
  return digit;
} // a != 0
template <typename T> void vecdbg(vector<T> &v) {
  rep(i, v.size()) { cout << v[i] << " "; }
  br;
}
template <typename T> void vecvecdbg(vector<vector<T>> &v) {
  rep(i, v.size()) {
    rep(j, v[i].size()) { cout << v[i][j] << " "; }
    br;
  }
}

// 0 false, 1 true
// string number to int : -48
// a to A : -32
// ceil(a)  1.2->2.0
// c++17	g++ -std=c++17 a.cpp
// global vector -> 0 initialization
ll ans = 0;

int main() {
  std::cout << std::fixed << std::setprecision(15);
  ll n;
  cin >> n;
  for (ll a = 1; a <= n - 1; a++) {
    ans += (n - 1) / a;
  }
  /*
  for(ll c = 1; c <= n-1; c++){
      ll tmp = n-c;
      p.divisor(tmp);

      if(v.size() % 2 == 0){
          ans += v.size();
      }else{
          ans += v.size() / 2 * 2 + 1;
      }

      cout << "v " << v.size() << endl;
      ans += (v.size() + 1)/ 2;
      cout << ans << endl;

  }*/

  cout << ans << endl;
}


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

#define ff first
#define fo(i, n) for (i = 0; i < n; i++)
#define Fo(i, k, n) for (i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define w(x)                                                                   \\
  int x;                                                                       \\
  cin >> x;                                                                    \\
  while (x--)
#define FIO                                                                    \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const int N = 3e5, M = N;
//=======================

void solve() {
  int i, j, n, m;
  cin >> n;
  int count = 0;
  for (i = 1; i <= n - 1; i++) {
    int ans = n - i;
    for (j = 1; j * j < ans; j++) {
      if (ans % j == 0) {
        count += 2;
      }
    }
    if (j * j == ans)
      count++;
  }
  cout << count;
}

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

  solve();
  return 0;
}

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

#define ff first
#define fo(i, n) for (i = 0; i < n; i++)
#define Fo(i, k, n) for (i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define vi vector<int>
#define mii map<int, int>
#define pqb priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define w(x)                                                                   \\
  int x;                                                                       \\
  cin >> x;                                                                    \\
  while (x--)
#define FIO                                                                    \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const int N = 3e5, M = N;
//=======================

void solve() {
  int i, j, n, m;
  cin >> n;
  vector<int> prime(1000, 0);

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

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

  solve();
  return 0;
}


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

const int MAX_N = 1000005;
std::vector<ll> num_divisor(MAX_N, 0);

ll init_num_divisor() {
  for (int i = 1; i < MAX_N; ++i) {
    for (int j = i; j < MAX_N; j += i) {
      num_divisor[j]++;
    }
  }
}

int main() {
  init_num_divisor();
  int N;
  cin >> N;
  ll cnt = 0;
  for (int c = 1; c < N; ++c)
    cnt += num_divisor[c];
  cout << cnt << endl;
  return 0;
}

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

const int MAX_N = 1000005;
std::vector<ll> num_divisor(MAX_N, 0);

void init_num_divisor() {
  for (int i = 1; i < MAX_N; ++i) {
    for (int j = i; j < MAX_N; j += i) {
      num_divisor[j]++;
    }
  }
}

int main() {
  init_num_divisor();
  int N;
  cin >> N;
  ll cnt = 0;
  for (int c = 1; c < N; ++c)
    cnt += num_divisor[c];
  cout << cnt << endl;
  return 0;
}


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

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<pdd> vdd;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mem(a, b) memset(a, b, sizeof(a))
#define all(x) (x).begin(), (x).end()
#define INF 1e18
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define F first
#define S second

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

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

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

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

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<pdd> vdd;

#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mem(a, b) memset(a, b, sizeof(a))
#define all(x) (x).begin(), (x).end()
#define INF 1e18
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define F first
#define S second

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

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

int main() {
  int n;
  cin >> n;
  int cnt = 0;
  for (int i = 1; i <= n - 1; ++i) {
    int m = n - i;
    map<int, int> a;
    set<int> b;
    for (int j = 2; j * j <= m; ++j) {
      if (m % j == 0) {
        b.insert(j);
        while (m % j == 0) {
          m /= j;
          a[j]++;
        }
      }
    }
    if (m != 1) {
      a[m]++;
      b.insert(m);
    }
    int ans = 1;
    for (auto x : b) {
      ans *= a[x] + 1;
    }
    cnt += ans;
  }

  cout << cnt << endl;
}


#include <bits/stdc++.h>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int findSumOfDigits(int n) {
  int sum = 0;
  while (n > 0) { // n が 0 になるまで
    sum += n % 10;
    n /= 10;
  }
  return sum;
}
int main() {
  long long n;
  cin >> n;
  long long ans = 0;
  for (long long i = 1; i <= n - 1; i++) {
    for (long long j = 1; j <= (n - 1); j++) {
      if (i * j <= n - 1)
        ans++;
    }
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int findSumOfDigits(int n) {
  int sum = 0;
  while (n > 0) { // n が 0 になるまで
    sum += n % 10;
    n /= 10;
  }
  return sum;
}
int main() {
  long long n;
  cin >> n;
  long long ans = 0;
  for (long long i = 1; i < n; i++) {
    ans += (n - 1) / i;
  }
  cout << ans << endl;
}


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

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

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

  // int ans = 0;
  // for (int c = 1; c < N; c++) {
  //     for (int a = 1; a * a <= N-c; a++) {
  //         int right = N - c;
  //         if (right % a == 0) {
  //             ans++;
  //             if (right / a != a) {
  //                 ans++;
  //             }
  //         }
  //     }
  // }
  // cout << ans << endl;

  ll ans = 0;
  for (int c = 1; c < N; c++) {
    vector<ll> res = enum_divisors(N - c);
    ans += res.size();
  }
  cout << ans << endl;
}

int main() {
  solve();
  return 0;
}

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

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

  ll ab = 0, ans = 0;
  for (ll a = 1; a * a < n; a++) {
    ab = a;
    ans += (n - 1) / a;
  }
  cout << 2 * ans - ab * ab << endl;
}

int main() {
  solve();
  return 0;
}


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

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

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

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


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll, ll>
#define FOR(I, A, B) for (ll I = ll(A); I < ll(B); ++I)
#define FORR(I, A, B) for (ll I = ll((B)-1); I >= ll(A); --I)
#define TO(x, t, f) ((x) ? (t) : (f))
#define SORT(x) (sort(x.begin(), x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x, v)                                                             \\
  (lower_bound(x.begin(), x.end(), v) - x.begin()) // xi>=v  x is sorted
#define POSU(x, v)                                                             \\
  (upper_bound(x.begin(), x.end(), v) - x.begin()) // xi>v  x is sorted
#define NUM(x, v) (POSU(x, v) - POSL(x, v))        // x is sorted
#define REV(x) (reverse(x.begin(), x.end()))       // reverse
ll gcd_(ll a, ll b) {
  if (a % b == 0)
    return b;
  return gcd_(b, a % b);
}
ll lcm_(ll a, ll b) {
  ll c = gcd_(a, b);
  return ((a / c) * b);
}
#define NEXTP(x) next_permutation(x.begin(), x.end())
const ll INF = ll(1e16) + ll(7);
const ll MOD = 1000000007LL;
#define out(a) cout << fixed << setprecision((a))
// tie(a,b,c) = make_tuple(10,9,87);
#define pop_(a) __builtin_popcount((a))
ll keta(ll a) {
  ll r = 0;
  while (a) {
    a /= 10;
    r++;
  }
  return r;
}

template <typename T> class Seg_Tree {
public: // 0-index
  vector<T> dat;
  T initial, M;
  int n;
  T unite(T a, T b) { //
    return a + b;
  }
  Seg_Tree(int n0_ = 1, T initial_ = 1, T M_ = 1) {
    initsize(n0_, initial_, M_);
  }
  void initsize(int n0, T initial_, T M_) {
    M = M_;
    initial = initial_;
    int k = 1;
    while (1) {
      if (n0 <= k) {
        n = k;
        dat.resize(2 * n - 1);
        for (int i = 0; i < 2 * n - 1; i++)
          dat[i] = initial;
        break;
      }
      k *= 2;
    }
  }

  // i banme wo x nisuru
  void update(int i, T x) {
    i += n - 1;
    dat[i] = x;
    while (i > 0) {
      i = (i - 1) / 2;
      dat[i] = unite(dat[i * 2 + 1], dat[i * 2 + 2]);
    }
  }

  //[a,b)
  T query0(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l)
      return initial;
    if (a <= l && r <= b)
      return dat[k];
    else {
      T vl = query0(a, b, k * 2 + 1, l, (l + r) / 2);
      T vr = query0(a, b, k * 2 + 2, (l + r) / 2, r);
      return unite(vl, vr);
    }
  }

  // return [a,b)
  T query(int a, int b) { return query0(a, b, 0, 0, n); }
};

vector<ll> enum_div(ll n) { // yakusu
  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 ret;
}

map<ll, ll> soinsubunkai(ll x) { // x = {first^second}*...
  map<ll, ll> ans;
  if (x == 1) {
    ans[1]++;
    return ans;
  }
  ll p = x;
  for (ll i = 2; i * i <= x; i++) {
    while (p % i == 0) {
      p /= i;
      ans[i]++;
    }
  }
  if (p != 1)
    ans[p]++;
  return ans;
}

int main() {

  ll N;

  cin >> N;

  ll ans = 0;

  FOR(c, 1, N) {
    ll k = N - c;
    for (ll i = 1; i * i <= k; ++i) {
      if (k % i == 0) {
        ans++;
        if (i * i != k)
          ans++;
      }
    }
  }

  cout << ans << endl;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll, ll>
#define FOR(I, A, B) for (ll I = ll(A); I < ll(B); ++I)
#define FORR(I, A, B) for (ll I = ll((B)-1); I >= ll(A); --I)
#define TO(x, t, f) ((x) ? (t) : (f))
#define SORT(x) (sort(x.begin(), x.end())) // 0 2 2 3 4 5 8 9
#define POSL(x, v)                                                             \\
  (lower_bound(x.begin(), x.end(), v) - x.begin()) // xi>=v  x is sorted
#define POSU(x, v)                                                             \\
  (upper_bound(x.begin(), x.end(), v) - x.begin()) // xi>v  x is sorted
#define NUM(x, v) (POSU(x, v) - POSL(x, v))        // x is sorted
#define REV(x) (reverse(x.begin(), x.end()))       // reverse
ll gcd_(ll a, ll b) {
  if (a % b == 0)
    return b;
  return gcd_(b, a % b);
}
ll lcm_(ll a, ll b) {
  ll c = gcd_(a, b);
  return ((a / c) * b);
}
#define NEXTP(x) next_permutation(x.begin(), x.end())
const ll INF = ll(1e16) + ll(7);
const ll MOD = 1000000007LL;
#define out(a) cout << fixed << setprecision((a))
// tie(a,b,c) = make_tuple(10,9,87);
#define pop_(a) __builtin_popcount((a))
ll keta(ll a) {
  ll r = 0;
  while (a) {
    a /= 10;
    r++;
  }
  return r;
}

template <typename T> class Seg_Tree {
public: // 0-index
  vector<T> dat;
  T initial, M;
  int n;
  T unite(T a, T b) { //
    return a + b;
  }
  Seg_Tree(int n0_ = 1, T initial_ = 1, T M_ = 1) {
    initsize(n0_, initial_, M_);
  }
  void initsize(int n0, T initial_, T M_) {
    M = M_;
    initial = initial_;
    int k = 1;
    while (1) {
      if (n0 <= k) {
        n = k;
        dat.resize(2 * n - 1);
        for (int i = 0; i < 2 * n - 1; i++)
          dat[i] = initial;
        break;
      }
      k *= 2;
    }
  }

  // i banme wo x nisuru
  void update(int i, T x) {
    i += n - 1;
    dat[i] = x;
    while (i > 0) {
      i = (i - 1) / 2;
      dat[i] = unite(dat[i * 2 + 1], dat[i * 2 + 2]);
    }
  }

  //[a,b)
  T query0(int a, int b, int k, int l, int r) {
    if (r <= a || b <= l)
      return initial;
    if (a <= l && r <= b)
      return dat[k];
    else {
      T vl = query0(a, b, k * 2 + 1, l, (l + r) / 2);
      T vr = query0(a, b, k * 2 + 2, (l + r) / 2, r);
      return unite(vl, vr);
    }
  }

  // return [a,b)
  T query(int a, int b) { return query0(a, b, 0, 0, n); }
};

vector<ll> enum_div(ll n) { // yakusu
  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 ret;
}

map<ll, ll> soinsubunkai(ll x) { // x = {first^second}*...
  map<ll, ll> ans;
  if (x == 1) {
    ans[1]++;
    return ans;
  }
  ll p = x;
  for (ll i = 2; i * i <= x; i++) {
    while (p % i == 0) {
      p /= i;
      ans[i]++;
    }
  }
  if (p != 1)
    ans[p]++;
  return ans;
}

int main() {

  ll N;

  cin >> N;

  ll ans = 0;

  FOR(a, 1, N) {
    ll b_max = N / a;
    if (b_max * a == N)
      b_max--;
    ans += b_max;
  }

  cout << ans << endl;
}