#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define mp make_pair
#define pu push
#define pp pop_back
#define in insert
#define forn(low, high, i) for (i = low; i < high; i++)
#define forrev(high, low, i)                                                   \\
  for (i = high; i >= low; i--)           // g++ ll.cpp -o ll.exe
#define zeroes(x) memset(x, 0, sizeof(x)) // all elements to 0
#define all(x) (x).begin(), (x).end()
typedef long long int ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
const ll mod = 1e9 + 7;
const ll maxn = 100000;

bool sortbysec(const pair<int, int> &a, // sorting of elements wrt second
               const pair<int, int> &b) {
  return (a.second < b.second);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return ans; // Total divisors
}

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

  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  ll n;
  cin >> n;

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

  SieveOfEratosthenes(n, prime, primesquare, a);

  ll sum1 = 1, sum;
  for (ll i = 2; i < n; ++i) {
    sum = countDivisors(i, a, prime, primesquare);
    /*sum+=sum;
    long double p;
    p=sqrt(i);
    if(p==(ll)p)
        sum--;*/

    sum1 += sum;
  }

  cout << sum1;

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define mp make_pair
#define pu push
#define pp pop_back
#define in insert
#define forn(low, high, i) for (i = low; i < high; i++)
#define forrev(high, low, i)                                                   \\
  for (i = high; i >= low; i--)           // g++ ll.cpp -o ll.exe
#define zeroes(x) memset(x, 0, sizeof(x)) // all elements to 0
#define all(x) (x).begin(), (x).end()
typedef long long int ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
const ll mod = 1e9 + 7;
const ll maxn = 100000;

bool sortbysec(const pair<int, int> &a, // sorting of elements wrt second
               const pair<int, int> &b) {
  return (a.second < b.second);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return ans; // Total divisors
}

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

  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  ll n;
  cin >> n;

  bool prime[n + 1], primesquare[2 * n];
  ll a[n];

  SieveOfEratosthenes(n, prime, primesquare, a);

  ll sum1 = 1, sum;
  for (ll i = 2; i < n; ++i) {
    sum = countDivisors(i, a, prime, primesquare);
    /*sum+=sum;
    long double p;
    p=sqrt(i);
    if(p==(ll)p)
        sum--;*/

    sum1 += sum;
  }

  cout << sum1;

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
bool isPerfectSquare(ll x) {
  long double sr = sqrt(x);
  return ((sr - floor(sr)) == 0);
}
bool isPrime(ll n) {
  // Corner cases
  if (n <= 1)
    return false;
  if (n <= 3)
    return true;

  // This is checked so that we can skip
  // middle five numbers in below loop
  if (n % 2 == 0 || n % 3 == 0)
    return false;

  for (int i = 5; i * i <= n; i = i + 6)
    if (n % i == 0 || n % (i + 2) == 0)
      return false;

  return true;
}
ll div(ll n) {
  ll cnt = 0;
  for (ll i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      if (n / i == i)
        cnt++;
      else
        cnt = cnt + 2;
    }
  }
  return cnt;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  ll n, counter = 0;
  cin >> n;
  for (ll i = 1; i < n; i++) {
    ll a = n - i;
    if (isPrime(a)) {
      counter += 2;
    } else {
      counter += div(a);
    }
  }
  cout << counter << endl;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
bool prime(ll n) {
  if (n <= 1)
    return false;
  if (n <= 3)
    return true;
  if (n % 2 == 0 || n % 3 == 0)
    return false;
  for (int i = 5; i * i <= n; i = i + 6)
    if (n % i == 0 || n % (i + 2) == 0)
      return false;

  return true;
}
ll div(ll n) {
  ll cnt = 0;
  for (ll i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      if (n / i == i)
        cnt++;
      else
        cnt = cnt + 2;
    }
  }
  return cnt;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  ll n, counter = 0;
  cin >> n;
  vector<ll> a(n + 1, 1);
  for (ll i = 2; i <= n; i++) {
    for (ll j = i; j <= n; j += i)
      a[j]++;
  }
  for (ll i = 1; i < n; i++) {
    counter += a[i];
  }
  cout << counter << endl;
}


#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;

bool IsPrime(int num) {
  if (num < 2)
    return false;
  else if (num == 2)
    return true;
  else if (num % 2 == 0)
    return false; // 偶数はあらかじめ除く

  double sqrtNum = sqrt(num);
  for (int i = 3; i <= sqrtNum; i += 2) {
    if (num % i == 0) {
      // 素数ではない
      return false;
    }
  }

  // 素数である
  return true;
}

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

  for (long i = n - 1; i > 0; i--) {
    if (IsPrime(i) == false) {
      long j = 0;
      if (pow((long)sqrt(i), 2) == i)
        count--;
      for (long j = (long)sqrt(i); j > 0; j--) {
        if (i % j == 0) {
          count += 2;
        }
      }
    } else {
      count += 2;
    }
  }

  cout << count;

  return 0;
}

#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;

bool IsPrime(int num) {
  if (num < 2)
    return false;
  else if (num == 2)
    return true;
  else if (num % 2 == 0)
    return false; // 偶数はあらかじめ除く

  double sqrtNum = sqrt(num);
  for (int i = 3; i <= sqrtNum; i += 2) {
    if (num % i == 0) {
      // 素数ではない
      return false;
    }
  }

  // 素数である
  return true;
}

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

  for (int i = n - 1; i > 0; i--) {
    if (i % 2 != 0) {
      if (IsPrime(i) == false) {
        int j = (int)sqrt(i);
        if (pow(j, 2) == i)
          count--;
        if (j % 2 == 0)
          j -= 1;
        for (j; j > 0; j -= 2) {
          if (i % j == 0) {
            count += 2;
          }
        }
      } else {
        count += 2;
      }
    } else {
      int j = (int)sqrt(i);
      if (pow(j, 2) == i)
        count--;
      for (j; j > 0; j -= 1) {
        if (i % j == 0) {
          count += 2;
        }
      }
    }
  }

  cout << count;

  return 0;
}


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

  for (ll C = 1; C < N; C++) {
    n = N - C;
    for (ll A = 1; A <= n; A++) {
      if (n % A == 0) {
        ans++;
      }
    }
  }

  cout << ans;
  cin >> N;

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; i++)
int main() {
  ll N;
  cin >> N;
  ll ans = N - 1;
  for (ll A = 2; A < N; A++) {
    ans = ans + N / A;
    if (N % A == 0)
      ans--;
  }
  cout << ans;
  cin >> N;

  return 0;
}


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

void SieveOfEratosthenes(int n, bool prime[], bool primesquare[], int a[]) {
  for (int i = 2; i <= n; i++)
    prime[i] = true;

  for (int i = 0; i <= (n * n + 1); i++)
    primesquare[i] = false;

  prime[1] = false;

  for (int p = 2; p * p <= n; p++) {
    if (prime[p] == true) {
      for (int i = p * 2; i <= n; i += p)
        prime[i] = false;
    }
  }

  int j = 0;
  for (int p = 2; p <= n; p++) {
    if (prime[p]) {

      a[j] = p;

      primesquare[p * p] = true;
      j++;
    }
  }
}

int countDivisors(int n) {

  if (n == 1)
    return 1;

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

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

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

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

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

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

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

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

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

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

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

  return ans; // Total divisors
}

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

  ll n, temp = 0;
  cin >> n;

  for (ll i = 0; i < n - 1; i++) {
    temp = temp + countDivisors(n - i - 1);
  }
  cout << temp << endl;
}

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

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

  ll n, temp = 0;
  cin >> n;

  for (ll i = 1; i <= n - 1; i++) {
    if (n % i == 0) {
      temp = temp + n / i - 1;
    } else {
      temp = temp + n / i;
    }
  }
  cout << temp << endl;
}


// #include <bits/stdc++.h>
#include <algorithm>
#include <climits>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <vector>
using namespace std;
const int INF = 1e9;
#define ll long long
#define int ll
#define fast                                                                   \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define testcase while (tt--)
#define pb push_back
#define endl "\\n"
#define deb1(x) cout << #x << ": " << x << endl
#define deb2(x, y) cout << #x << ": " << x << " | " << #y << ": " << y << endl
#define deb3(x, y, z)                                                          \\
  cout << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": "   \\
       << z << endl
#define deb4(x, y, z, w)                                                       \\
  cout << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": "   \\
       << z << " | " << #w << ": " << w << endl
#define deb5(a, b, c, d, e)                                                    \\
  cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(a) int((a).size())
#define pii pair<int, int>
#define fi first
#define se second
#define ld long double
#define vii vector<int>
#define all(v) v.begin(), v.end()
#define prec(n) fixed << setprecision(n)
#define printclock                                                             \\
  cerr << "Time : " << 1000 * (ld)clock() / (ld)CLOCKS_PER_SEC << "ms\\n";
const int MOD = 998244353;
const int MOD2 = 429496729;
const ll LINF = (ll)1e18;
const ld PI = acos((ld)-1);
const ld EPS = 1e-12;
inline ll gcd(ll a, ll b) {
  ll r;
  while (b) {
    r = a % b;
    a = b;
    b = r;
  }
  return a;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline ll fpow(ll n, ll k, int p = MOD) {
  ll r = 1;
  for (; k; k >>= 1) {
    if (k & 1)
      r = r * n % p;
    n = n * n % p;
  }
  return r;
}
template <class T> inline int chkmin(T &a, const T &val) {
  return val < a ? a = val, 1 : 0;
}
template <class T> inline int chkmax(T &a, const T &val) {
  return a < val ? a = val, 1 : 0;
}
inline void addmod(int &a, int val, int p = MOD) {
  if ((a = (a + val)) >= p)
    a -= p;
}
inline void submod(int &a, int val, int p = MOD) {
  if ((a = (a - val)) < 0)
    a += p;
}
inline int mult(int a, int b, int p = MOD) { return (ll)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
template <class T> inline void get_arr(T arr[], int n) {
  for (int i = 0; i < n; i++)
    cin >> arr[i];
}
template <class T> inline void print_arr(T arr[], int n) {
  for (int i = 0; i < n; i++)
    cout << arr[i] << " ";
  cout << endl;
}
template <class T> inline void print_vec(vector<T> arr) {
  for (int i = 0; i < arr.size(); i++)
    cout << arr[i] << " ";
  cout << endl;
}

// const int N=1e7+5;
// int prime[N]={0};

int32_t main() {
  fast;
#ifndef ONLINE_JUDGE
  freopen("./input.txt", "r", stdin);
  // freopen("./output.txt","w",stdout);
#endif
  int tt = 1;
  // cin >> tt;
  // int ttt=tt;
  testcase {

    const int N = 1e6 + 8;
    int arr[N] = {0};
    for (int i = 1; i < N; i++) {
      for (int j = 1; j * j <= i; j++) {
        if (i % j == 0) {
          arr[i]++;
          if (i / j != j)
            arr[i]++;
        }
      }
    }
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i < n; i++) {
      ans += arr[n - i];
    }
    cout << ans << endl;
  }
  // printclock;
  return 0;
}

// #include <bits/stdc++.h>
#include <algorithm>
#include <climits>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stack>
#include <string.h>
#include <unordered_map>
#include <vector>
using namespace std;
const int INF = 1e9;
#define ll long long
#define int ll
#define fast                                                                   \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);                                                                  \\
  cout.tie(0);
#define testcase while (tt--)
#define pb push_back
#define endl "\\n"
#define deb1(x) cout << #x << ": " << x << endl
#define deb2(x, y) cout << #x << ": " << x << " | " << #y << ": " << y << endl
#define deb3(x, y, z)                                                          \\
  cout << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": "   \\
       << z << endl
#define deb4(x, y, z, w)                                                       \\
  cout << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": "   \\
       << z << " | " << #w << ": " << w << endl
#define deb5(a, b, c, d, e)                                                    \\
  cout << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": "   \\
       << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(a) int((a).size())
#define pii pair<int, int>
#define fi first
#define se second
#define ld long double
#define vii vector<int>
#define all(v) v.begin(), v.end()
#define prec(n) fixed << setprecision(n)
#define printclock                                                             \\
  cerr << "Time : " << 1000 * (ld)clock() / (ld)CLOCKS_PER_SEC << "ms\\n";
const int MOD = 998244353;
const int MOD2 = 429496729;
const ll LINF = (ll)1e18;
const ld PI = acos((ld)-1);
const ld EPS = 1e-12;
inline ll gcd(ll a, ll b) {
  ll r;
  while (b) {
    r = a % b;
    a = b;
    b = r;
  }
  return a;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
inline ll fpow(ll n, ll k, int p = MOD) {
  ll r = 1;
  for (; k; k >>= 1) {
    if (k & 1)
      r = r * n % p;
    n = n * n % p;
  }
  return r;
}
template <class T> inline int chkmin(T &a, const T &val) {
  return val < a ? a = val, 1 : 0;
}
template <class T> inline int chkmax(T &a, const T &val) {
  return a < val ? a = val, 1 : 0;
}
inline void addmod(int &a, int val, int p = MOD) {
  if ((a = (a + val)) >= p)
    a -= p;
}
inline void submod(int &a, int val, int p = MOD) {
  if ((a = (a - val)) < 0)
    a += p;
}
inline int mult(int a, int b, int p = MOD) { return (ll)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
template <class T> inline void get_arr(T arr[], int n) {
  for (int i = 0; i < n; i++)
    cin >> arr[i];
}
template <class T> inline void print_arr(T arr[], int n) {
  for (int i = 0; i < n; i++)
    cout << arr[i] << " ";
  cout << endl;
}
template <class T> inline void print_vec(vector<T> arr) {
  for (int i = 0; i < arr.size(); i++)
    cout << arr[i] << " ";
  cout << endl;
}

// const int N=1e7+5;
// int prime[N]={0};

int32_t main() {
  fast;
#ifndef ONLINE_JUDGE
  freopen("./input.txt", "r", stdin);
  // freopen("./output.txt","w",stdout);
#endif
  int tt = 1;
  // cin >> tt;
  // int ttt=tt;
  testcase {
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i < n; i++) {
      ans += n / i;
      if (n % i == 0)
        ans--;
    }
    cout << ans << endl;
  }
  // printclock;
  return 0;
}


#include <algorithm> //sort(a.begin(), a.end());reverse(a.begin(), a.end());
#include <bits/stdc++.h>
#include <iostream>
#include <math.h> //pow(x,y)=x^y 99999とかの場合+1するif文
#define rep(init, i, n) for (int i = init; i < (n); i++)
#define ll long long
#define rev(s) reverse(s.begin(), s.end())
#define sor(v) sort(v.begin(), v.end())
#define PI 3.14159265358979323846264338327950L
// コード自動整形 Shift + Option + F @vscode
using namespace std;

ll facctorialMethod(ll k); // 階乗を出力する

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

/////main/////
int main() {
  ll N;
  cin >> N;
  vector<ll> output = divisor(N);
  ll sum = 0;

  rep(2, i, N + 1) { // 2--N
    ll imput = i - 1;
    vector<ll> output = divisor(imput);
    sum += output.size();
  }
  cout << sum << endl;
  /*rep(0,i,output.size()){
      cout<<output.at(i)<<endl;
  }*/

  // cout<<output.size()<<endl;
}
/////main/////

/////function/////

#include <algorithm> //sort(a.begin(), a.end());reverse(a.begin(), a.end());
#include <bits/stdc++.h>
#include <iostream>
#include <math.h> //pow(x,y)=x^y 99999とかの場合+1するif文
#define ll long long
#define rep(init, i, n) for (ll i = init; i < (n); i++)
#define rev(s) reverse(s.begin(), s.end())
#define sor(v) sort(v.begin(), v.end())
#define PI 3.14159265358979323846264338327950L
// コード自動整形 Shift + Option + F @vscode
using namespace std;

/////main/////
int main() {
  ll N, sum;
  cin >> N;
  sum = 0;
  ll temp = 0;
  rep(0, i, N / 2) {
    if (N % (1 + i) == 0) {
      temp = N / (i + 1) - 1;
      sum += temp;
    } else {
      temp = N / (i + 1);
      sum += temp;
    }
    // cout << temp << endl;
  }
  sum += N - N / 2 - 1;
  cout << sum << endl;
}
/////main/////

/////function/////


#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ull unsigned long long
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define mii map<int, int>
#define pii pair<int, int>
#define pq priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define w(t)                                                                   \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repd(i, a, b) for (int i = a; i >= b; i--)
long pairmultiply(int x) {
  long ans = 2, p = sqrt(x);
  for (int i = 2; i <= p; i++) {
    if (x % i == 0)
      ans += 2;
  }
  if (p * p == x)
    ans--;
  return ans;
}
int32_t main() {
  int n;
  cin >> n;
  long ans = 1;
  for (int i = 2; i < n; i++) {
    long x = pairmultiply(i);
    ans += x;
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ull unsigned long long
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define mii map<int, int>
#define pii pair<int, int>
#define pq priority_queue<int>
#define pqs priority_queue<int, vi, greater<int>>
#define mod 1000000007
#define inf 1e18
#define ps(x, y) fixed << setprecision(y) << x
#define w(t)                                                                   \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define rep(i, a, b) for (int i = a; i < b; i++)
#define repd(i, a, b) for (int i = a; i >= b; i--)
int32_t main() {
  int n, ans = 0;
  cin >> n;
  vector<int> dp(n, 0);
  for (int i = 1; i < n; i++)
    for (int j = i; j < n; j = j + i)
      dp[j]++;
  for (int i = 1; i < n; i++)
    ans += dp[i];
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
#define M 1000000007
#define pi 3.14159265358979323846
#define cel(x, a) (x + a - 1) / a
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define vpi vector<pii>
#define vpl vector<pll>
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define ps(x, y) fixed << setprecision(y) << x
#define pf(x, y) setfill('x') << setw(y)
#define mp make_pair
#define F first
#define S second
/*.*Ashish_akj*.*/
#define lcm(m, n) (m / __gcd(m, n)) * n
#define all(v) v.begin(), v.end()
using namespace std;
const int N = 2e6 + 4;
/*
int ncr(int n, int r)
{
    long long p = 1, k = 1;
    if (n - r < r)
        r = n - r;

    if (r != 0) {
        while (r) {
            p *= n;
            k *= r;
            long long m = __gcd(p, k);
            p /= m;
            k /= m;

            n--;
            r--;
        }
    }

    else
        p = 1;
    return p;
} */
/*vector<bool>visited;
 vector<vector<int>>adj;
void dfs(int v)
{visited[v]=true;
for(int i:adj[v])
{if(!visited){dfs(i);}
}}
*/
int cont(int no) {
  int cnt = 0;
  for (int i = 1; i <= sqrt(no); i++) {
    if (no % i == 0) {
      if (no / i == i) {
        cnt++;
      } else {
        cnt = cnt + 2;
      }
    }
  }
  return cnt;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; i++) {
    int p = cont(i);
    ans += p;
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
#define M 1000000007
#define pi 3.14159265358979323846
#define cel(x, a) (x + a - 1) / a
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define vpi vector<pii>
#define vpl vector<pll>
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define ps(x, y) fixed << setprecision(y) << x
#define pf(x, y) setfill('x') << setw(y)
#define mp make_pair
#define F first
#define S second
/*.*Ashish_akj*.*/
#define lcm(m, n) (m / __gcd(m, n)) * n
#define all(v) v.begin(), v.end()
using namespace std;
const int N = 2e6 + 4;
/*
int ncr(int n, int r)
{
    long long p = 1, k = 1;
    if (n - r < r)
        r = n - r;

    if (r != 0) {
        while (r) {
            p *= n;
            k *= r;
            long long m = __gcd(p, k);
            p /= m;
            k /= m;

            n--;
            r--;
        }
    }

    else
        p = 1;
    return p;
} */
/*vector<bool>visited;
 vector<vector<int>>adj;
void dfs(int v)
{visited[v]=true;
for(int i:adj[v])
{if(!visited){dfs(i);}
}}
*/
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i < n; i++) {
    int p = (n - 1) / i;
    ans += p;
  }
  cout << ans;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
long long enum_divisors(long long N) {
  long long res = 0;
  for (long long i = 1; i * i <= N; ++i) {
    if (N % i == 0) {
      res++;
      if (N / i != i)
        res++;
    }
  }
  return res;
}
int main() {
  int n;
  cin >> n;
  long long ans = 0;
  for (int i = 1; i <= n; i++) {
    long long p = enum_divisors(n - i);
    ans += p;
  }
  cout << ans << endl;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
long long enum_divisors(int N) {
  long long res = 0;
  for (int i = 1; i * i <= N; ++i) {
    if (N % i == 0) {
      res++;
      if (N / i != i)
        res++;
    }
  }
  return res;
}
int main() {
  int n;
  cin >> n;
  long long ans = 0;
  for (int i = 1; i <= n; i++) {
    long long p = enum_divisors(n - i);
    ans += p;
  }
  cout << ans << endl;
  return 0;
}


/// in the name of ALLAH
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
  ll n;
  cin >> n;
  ll c, ans = 0;
  for (int i = 1; i < n; i++) {
    ll x = n - i;
    c = 0;
    for (int i = 1; i <= sqrt(x); i++) {
      if (x % i == 0) {
        if (x / i == i)
          c++;
        else
          c += 2;
      }
    }
    ans += c;
  }
  cout << ans << endl;
}

#include <bits/stdc++.h>
#define mx 1005
using namespace std;
typedef long long ll;
vector<ll> prime;
void sieve() {
  bool flag[mx];
  memset(flag, 0, sizeof(flag));
  flag[1] = 1;
  for (int i = 4; i <= mx; i += 2) {
    flag[i] = 1;
  }
  for (int i = 3; i <= sqrt(mx); i += 2) {
    if (flag[i] == 0) {
      for (int j = 2 * i; j <= mx; j += i)
        flag[j] = 1;
    }
  }
  for (int i = 2; i < mx; i++) {
    if (flag[i] == 0) {
      prime.push_back(i);
    }
  }
  // for(int i=0;i<10;++i)
  // cout<<prime[i]<<endl;
}
ll NumOfDivisors(ll n) {
  ll sqrtn = sqrt(n);
  ll c = 0, ans = 1;
  for (int i = 0; i < prime.size() && prime[i] <= sqrtn; i++) {
    if (n % prime[i] == 0) {
      c = 0;
      while (n % prime[i] == 0) {
        n /= prime[i];
        c++;
      }
      sqrtn = sqrt(n);
      ans *= (c + 1);
    }
  }

  if (n != 1) {
    ans *= 2;
  }
  return ans;
}
int main() {
  ll n;
  cin >> n;
  ll c, ans = 0;
  sieve();
  ll x;
  for (int i = 1; i < n; i++) {
    x = NumOfDivisors(n - i);
    ans += x;
  }
  cout << ans << endl;
}


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

vector<vector<long long>> Factrization(long long X);

int main() {
  long long N, N_dash;
  vector<vector<long long>> facts;
  long long ans = 0;
  std::cin >> N;

  for (long long i = 1; i <= N - 1; i++) {
    N_dash = N - i;
    facts = Factrization(N_dash);
    ans = ans + Factrization(N_dash).size() * 2;
    if (facts[facts.size() - 1][0] == facts[facts.size() - 1][1]) {
      ans = ans - 1;
    }
  }

  std::cout << ans;
}

vector<vector<long long>> Factrization(long long X) {
  vector<vector<long long>> factors = {};
  long long n_loop, a, b;

  n_loop = (long long)floor(sqrt((float)X));
  for (long long i = 1; i <= n_loop; i++) {
    if (X % i == 0) {
      a = i;
      b = X / i;
      factors.push_back({a, b});
    }
  }
  return factors;
}

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

vector<vector<long long>> Factrization(long long X);

int main() {
  long long N, N_dash;
  long long pi;
  vector<vector<long long>> facts;
  long long ans = 0;
  std::cin >> N;

  for (long long i = 1; i <= N - 1; i++) {
    pi = (long long)floor(((double)N - 1.0) / (double)i);
    for (long long j = 1; j <= pi; j++) {
      ans++;
    }
  }

  std::cout << ans;
}

vector<vector<long long>> Factrization(long long X) {
  vector<vector<long long>> factors = {};
  long long n_loop, a, b;

  n_loop = (long long)floor(sqrt((float)X));
  for (long long i = 1; i <= n_loop; i++) {
    if (X % i == 0) {
      a = i;
      b = X / i;
      factors.push_back({a, b});
    }
  }
  return factors;
}


#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <chrono>
#include <random>
#include <unordered_map>

using namespace std;

typedef long long ll;

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i <= n; i++) {
    int cur = n - i;
    for (int j = 1; j * j <= cur; j++) {
      if (cur % j == 0) {
        ans++;
        if (j * j != cur)
          ans++;
      }
    }
  }

  cout << ans;
}

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
#if defined(_DEBUG)
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  int q = 1;
  // cin >> q;
  for (; q > 0; q--) {
    solve();
    // cout << endl;
  }
}

#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#include <chrono>
#include <random>
#include <unordered_map>

using namespace std;

typedef long long ll;

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  int sq = sqrt(n) + 1;

  for (int i = 1; i <= sq; i++) {
    for (int j = i; j <= n / i; j++) {
      if (i * j < n) {
        ans++;
        if (i != j)
          ans++;
      }
    }
  }

  cout << ans;
}

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
#if defined(_DEBUG)
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#endif
  int q = 1;
  // cin >> q;
  for (; q > 0; q--) {
    solve();
    // cout << endl;
  }
}


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

#include <bits/stdc++.h>
using namespace std;
// 素因数分解

long long divisor_num(long long a) {
  long long ans = 1;

  for (int i = 2; i <= sqrt(a); i++) {
    int cnt = 0;
    while (a % i == 0) {
      cnt++;
      a /= i;
    }
    ans *= (cnt + 1);
    if (a == 1)
      break;
  }
  if (a != 1)
    ans *= 2;

  return ans;
}

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


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

using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
using vs = vector<string>;
using vb = vector<bool>;
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define FORR(i, m, n) for (int i = (m); i >= (n); i--)
#define REP(i, n) FOR(i, 0, (n))
#define REPR(i, n) FORR(i, (n)-1, 0)
#define REP1(i, n) FOR(i, 1, (n) + 1)
#define REPS(c, s) for (char c : s)
#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define REV(c) reverse(ALL(c))
#define sz(v) (int)v.size()
#define endl '\\n'
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;
}
template <class T> inline void prn(vector<T> &v) {
  int n = sz(v);
  REP(i, n) cout << v[i] << ' ';
}
template <class T> inline void printv(vector<T> &v) {
  int n = sz(v);
  REP(i, n) cout << v[i] << (i == n - 1 ? endl : ' ');
}
template <class T> inline void printvv(vector<vector<T>> &v) {
  for (auto u : v)
    printv(u);
}
template <class T> inline void printlnv(vector<T> &v) {
  int n = sz(v);
  REP(i, n) cout << v[i] << endl;
}
const int MOD = 1000000007;
const int INF = 1000000001;
const ll LINF = 1000000001000000001LL;

void solve();

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout << fixed << setprecision(numeric_limits<double>::max_digits10);
  solve();
  return 0;
}

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

map<ll, ll> prime_factorization(ll n) {
  map<ll, ll> m;
  ll x = n;
  ll d = 2;
  while (x > 1 && d * d <= n) {
    if (x % d == 0) {
      m[d]++;
      x /= d;
    } else {
      d++;
    }
  }
  if (x != 1)
    m[x]++;
  return m;
}

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  vector<map<ll, ll>> memo(n + 1);
  for (int c = n - 1; c > 0; c--) {
    int x = n - c;
    if (x % 2 == 0) {
      auto z = memo[x / 2];
      z[2]++;
      memo[x] = z;
    } else if (x % 3 == 0) {
      auto z = memo[x / 3];
      z[3]++;
      memo[x] = z;
    } else {
      auto d = prime_factorization(x);
      memo[x] = d;
    }
    if (x == 1)
      ans++;
    else {
      int s = 1;
      for (auto t : memo[x])
        s *= t.second + 1;
      ans += s;
    }
  }
  cout << ans << endl;
}

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

using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
using vs = vector<string>;
using vb = vector<bool>;
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define FORR(i, m, n) for (int i = (m); i >= (n); i--)
#define REP(i, n) FOR(i, 0, (n))
#define REPR(i, n) FORR(i, (n)-1, 0)
#define REP1(i, n) FOR(i, 1, (n) + 1)
#define REPS(c, s) for (char c : s)
#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define REV(c) reverse(ALL(c))
#define sz(v) (int)v.size()
#define endl '\\n'
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;
}
template <class T> inline void prn(vector<T> &v) {
  int n = sz(v);
  REP(i, n) cout << v[i] << ' ';
}
template <class T> inline void printv(vector<T> &v) {
  int n = sz(v);
  REP(i, n) cout << v[i] << (i == n - 1 ? endl : ' ');
}
template <class T> inline void printvv(vector<vector<T>> &v) {
  for (auto u : v)
    printv(u);
}
template <class T> inline void printlnv(vector<T> &v) {
  int n = sz(v);
  REP(i, n) cout << v[i] << endl;
}
const int MOD = 1000000007;
const int INF = 1000000001;
const ll LINF = 1000000001000000001LL;

void solve();

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout << fixed << setprecision(numeric_limits<double>::max_digits10);
  solve();
  return 0;
}

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

map<ll, ll> prime_factorization(ll n) {
  map<ll, ll> m;
  ll x = n;
  ll d = 2;
  while (x > 1 && d * d <= n) {
    if (x % d == 0) {
      m[d]++;
      x /= d;
    } else {
      d++;
    }
  }
  if (x != 1)
    m[x]++;
  return m;
}

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  vector<map<ll, ll>> memo(n + 1);
  for (int c = n - 1; c > 0; c--) {
    int x = n - c;
    if (x % 2 == 0) {
      auto z = memo[x / 2];
      z[2]++;
      memo[x] = z;
    } else if (x % 3 == 0) {
      auto z = memo[x / 3];
      z[3]++;
      memo[x] = z;
    } else if (x % 5 == 0) {
      auto z = memo[x / 5];
      z[5]++;
      memo[x] = z;
    } else if (x % 7 == 0) {
      auto z = memo[x / 7];
      z[7]++;
      memo[x] = z;
    } else {
      auto d = prime_factorization(x);
      memo[x] = d;
    }
    if (x == 1)
      ans++;
    else {
      int s = 1;
      for (auto t : memo[x])
        s *= t.second + 1;
      ans += s;
    }
  }
  cout << ans << endl;
}


/**
 *@Author : Shreyas Pandey
 *Team : AntiPython
 *[2020-09-19 10:16]
 **/

#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define vll vector<ll>
#define vvll vector<vll> // vector<vector<vll>>
#define vld vector<ld>
#define vvld vector<vld> // vector <vector <long double>>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define mp make_pair
#define pb push_back
#define MOD 1000000007
#define endl "\\n"
#define flash                                                                  \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);
#define test                                                                   \\
  ll t;                                                                        \\
  read(t);                                                                     \\
  while (t--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define fst first
#define scd second

#define forn(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define for1(i, n) for (ll(i) = 1; (i) <= (n); ++(i))
#define forr(i, n) for (ll(i) = (n)-1; (i) >= 0; --(i))
#define forab(i, a, b, c) for (ll(i) = a; (i) <= (b); (i) += (c))

using namespace std;
void online_judge() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
  freopen("error.txt", "w", stderr);
#endif
}

////////////////////////////////////////////////////////////////// Inputs
///////////////////////////////////////////////////////////////////////////////////////
template <typename T> void read(T &x) { cin >> x; }

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

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

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

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

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

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

///////////////////////////////////////////////////////////////////////////
///Outputs
///////////////////////////////////////////////////////////////////////////////

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

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

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

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

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

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

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

template <typename T, typename T0> void write(map<T, T0> &mpp) {
  for (auto it : mpp) {
    write(it.fst);
    cout << ": ";
    write(it.scd);
    cout << "\\n";
  }
  cout << endl;
}

///////////////////////////////////////////////////////////////////////// Maths
/////////////////////////////////////////////////////////////////////////////////

vll sieve;
void Sieve(int N) {
  const ll maxn = N;
  sieve.resize(maxn);
  forn(i, maxn) sieve[i] = i;
  sieve[1] = -1;
  sieve[0] = -1;
  forab(i, 2, maxn, 1) if (i == sieve[i]) for (ll j = 2 * i; j < maxn;
                                               j += i) if (sieve[j] == j)
      sieve[j] = i;
}

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

ll modinv(ll a, ll mod = MOD) {
  ll x, y;
  extended_GCD(a, mod, x, y);
  if (x < 0)
    x += mod;
  return x;
}
ll int sum_form(ll int k) { return ((k * (k + 1)) / 2); }
ll int binarySearch(ll int l, ll int r, ll int n) {
  ll ans = -1;
  while (l <= r) {
    ll int mid = l + (r - l) / 2;
    ll sum_l = sum_form(mid);
    ll sum_r = sum_form(n) - sum_l;
    if (sum_l == sum_r) {
      ans = mid;
      return ans;
    } else if (sum_l > sum_r) {
      r = mid - 1;
    } else {
      ans = mid;
      l = mid + 1;
    }
  }
  return ans;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////Segment
///Tree//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void solve() {
  int n;
  cin >> n;
  int cost = 0;
  for (int i = 1; i < n; ++i) {
    ll x = n - i;
    for (int j = 1; j * j <= x; j++) {
      if (x % j == 0) {
        if (j == x / j) {
          cost++;
        } else {
          cost += 2;
        }
      }
    }
  }
  cout << cost << "\\n";
}

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

/**
 *@Author : Shreyas Pandey
 *Team : AntiPython
 *[2020-09-19 10:16]
 **/

#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define vll vector<ll>
#define vvll vector<vll> // vector<vector<vll>>
#define vld vector<ld>
#define vvld vector<vld> // vector <vector <long double>>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define mp make_pair
#define pb push_back
#define MOD 1000000007
#define endl "\\n"
#define flash                                                                  \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);
#define test                                                                   \\
  ll t;                                                                        \\
  read(t);                                                                     \\
  while (t--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define fst first
#define scd second

#define forn(i, n) for (ll(i) = 0; (i) < (n); ++(i))
#define for1(i, n) for (ll(i) = 1; (i) <= (n); ++(i))
#define forr(i, n) for (ll(i) = (n)-1; (i) >= 0; --(i))
#define forab(i, a, b, c) for (ll(i) = a; (i) <= (b); (i) += (c))

using namespace std;
void online_judge() {
#ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
  freopen("error.txt", "w", stderr);
#endif
}

////////////////////////////////////////////////////////////////// Inputs
///////////////////////////////////////////////////////////////////////////////////////
template <typename T> void read(T &x) { cin >> x; }

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

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

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

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

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

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

///////////////////////////////////////////////////////////////////////////
///Outputs
///////////////////////////////////////////////////////////////////////////////

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

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

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

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

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

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

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

template <typename T, typename T0> void write(map<T, T0> &mpp) {
  for (auto it : mpp) {
    write(it.fst);
    cout << ": ";
    write(it.scd);
    cout << "\\n";
  }
  cout << endl;
}

///////////////////////////////////////////////////////////////////////// Maths
/////////////////////////////////////////////////////////////////////////////////

vll sieve;
void Sieve(int N) {
  const ll maxn = N;
  sieve.resize(maxn);
  forn(i, maxn) sieve[i] = i;
  sieve[1] = -1;
  sieve[0] = -1;
  forab(i, 2, maxn, 1) if (i == sieve[i]) for (ll j = 2 * i; j < maxn;
                                               j += i) if (sieve[j] == j)
      sieve[j] = i;
}

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

ll modinv(ll a, ll mod = MOD) {
  ll x, y;
  extended_GCD(a, mod, x, y);
  if (x < 0)
    x += mod;
  return x;
}
ll int sum_form(ll int k) { return ((k * (k + 1)) / 2); }
ll int binarySearch(ll int l, ll int r, ll int n) {
  ll ans = -1;
  while (l <= r) {
    ll int mid = l + (r - l) / 2;
    ll sum_l = sum_form(mid);
    ll sum_r = sum_form(n) - sum_l;
    if (sum_l == sum_r) {
      ans = mid;
      return ans;
    } else if (sum_l > sum_r) {
      r = mid - 1;
    } else {
      ans = mid;
      l = mid + 1;
    }
  }
  return ans;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////Segment
///Tree//////////////////////////////////////////////////////////////////////////////

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

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


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

inline int read() {
  int s = 0, w = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-')
      w = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9')
    s = s * 10 + ch - '0', ch = getchar();
  return s * w;
}

inline bool read(int &a) {
  int s = 0, w = 1;
  char ch = getchar();
  if (ch == EOF) {
    return false;
  }
  while (ch < '0' || ch > '9') {
    if (ch == '-')
      w = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9')
    s = s * 10 + ch - '0', ch = getchar();
  a = s * w;
  return true;
}

inline void write(int x) {
  if (x < 0)
    putchar('-'), x = -x;
  if (x > 9)
    write(x / 10);
  putchar(x % 10 + '0');
}

inline void writeln(int x) {
  if (x < 0)
    putchar('-'), x = -x;
  if (x > 9)
    write(x / 10);
  putchar(x % 10 + '0');
  puts("");
}

signed main() {
  int n = read();

  int ans = 0;

  for (register int i = 1; i <= n - 1; i++) {
    int now = n - i;
    for (register int j = 1; j * j <= now; j++) {
      if (now % j == 0 && now != j * j)
        ans += 2;
      else if (now % j == 0)
        ans++;
    }
  }

  writeln(ans);
  return 0;
}

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

inline int read() {
  int s = 0, w = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-')
      w = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9')
    s = s * 10 + ch - '0', ch = getchar();
  return s * w;
}

inline bool read(int &a) {
  int s = 0, w = 1;
  char ch = getchar();
  if (ch == EOF) {
    return false;
  }
  while (ch < '0' || ch > '9') {
    if (ch == '-')
      w = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9')
    s = s * 10 + ch - '0', ch = getchar();
  a = s * w;
  return true;
}

inline void write(int x) {
  if (x < 0)
    putchar('-'), x = -x;
  if (x > 9)
    write(x / 10);
  putchar(x % 10 + '0');
}

inline void writeln(int x) {
  if (x < 0)
    putchar('-'), x = -x;
  if (x > 9)
    write(x / 10);
  putchar(x % 10 + '0');
  puts("");
}

signed main() {
  int n = read();

  int ans = 0;

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

  writeln(ans);
  return 0;
}


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

ll yaku(ll a) {
  ll ans = 0;
  ll tmp = sqrt(a);
  rep(i, 1, tmp + 1) {
    if (a % i == 0 && a / i == i)
      ans++;
    else if (a % i == 0)
      ans += 2;
  }
  return ans;
}

int main() {
  int N;
  cin >> N;
  ll ans = 0;
  rep(i, 1, N) { ans += yaku(i); }
  cout << ans << endl;
}

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

int main() {
  int N;
  cin >> N;
  ll ans = 0;
  rep(i, 1, N) ans += (N - 1) / i;

  cout << ans << endl;
}


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

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


#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define lb lower_bound
#define ub upper_bound
#define owo                                                                    \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);
#define MOD (ll)(998244353)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d)                                                              \\
  for (long blockTime = 0;                                                     \\
       (blockTime == 0 ? (blockTime = clock()) != 0 : false);                  \\
       debug("%s time : %.4fs\\n", d,                                           \\
             (double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> PII;
typedef pair<int, int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
ll gcd(ll a, ll b) {
  if (!b)
    return a;
  else
    return gcd(b, a % b);
}
ll prime[100001];
ll phi[1000001];
vector<ll> p;
void sieve(int n) {
  prime[1] = 1;
  for (int i = 2; i <= n; i++) {
    if (prime[i] == 0) {
      prime[i] = i;
      p.pb(i);
    }
    for (int j = 0; j < (int)(p.size()) && p[j] <= prime[i] && i * p[j] <= n;
         j++) {
      prime[i * p[j]] = p[j];
    }
  }
}
int main() {
  int n;
  cin >> n;
  ll ans = 0;
  sieve(n);
  for (int i = 1; i < n; i++) {
    ll num = 1;
    int j = i;
    while (j != 1) {
      ll cnt = 0;
      int p = prime[j];
      while (j % p == 0) {
        j /= p;
        cnt++;
      }
      num *= (cnt + 1);
    }
    ans += num;
  }
  cout << ans << '\\n';
}

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define lb lower_bound
#define ub upper_bound
#define owo                                                                    \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);
#define MOD (ll)(998244353)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#define time__(d)                                                              \\
  for (long blockTime = 0;                                                     \\
       (blockTime == 0 ? (blockTime = clock()) != 0 : false);                  \\
       debug("%s time : %.4fs\\n", d,                                           \\
             (double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll, ll> PII;
typedef pair<int, int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
ll gcd(ll a, ll b) {
  if (!b)
    return a;
  else
    return gcd(b, a % b);
}
ll prime[1000005];
ll phi[1000005];
vector<ll> p;
void sieve(int n) {
  prime[1] = 1;
  for (int i = 2; i <= n; i++) {
    if (prime[i] == 0) {
      prime[i] = i;
      p.pb(i);
    }
    for (int j = 0; j < (int)(p.size()) && p[j] <= prime[i] && i * p[j] <= n;
         j++) {
      prime[i * p[j]] = p[j];
    }
  }
}
int main() {
  int n;
  cin >> n;
  ll ans = 0;
  sieve(n);
  for (int i = 1; i < n; i++) {
    ll num = 1;
    int j = i;
    while (j != 1) {
      ll cnt = 0;
      int p = prime[j];
      while (j % p == 0) {
        j /= p;
        cnt++;
      }
      num *= (cnt + 1);
    }
    ans += num;
  }
  cout << ans << '\\n';
}


#include <iostream>
using namespace std;

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

#include <iostream>
using namespace std;

int main() {
  int n;
  cin >> n;
  long long int count = 0;
  for (int i = 1; i < n; i++) {
    count += n / i;
    if (n % i == 0)
      count--;
  }
  cout << count << endl;
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll num(int n) {
  ll coun = 2;
  for (int i = 2; i <= sqrt(n); i++) {
    if (n % i == 0) {
      if (i == sqrt(n) && n / i == i) {
        coun++;
      } else
        coun += 2;
    }
  }
  return coun;
}
int main() {

  int n;
  scanf("%d", &n);
  ll ans = 0;
  for (int i = 1; i < n; i++) {
    if (i == 1) {
      ans += 1;
      continue;
    }
    ans += num(i);
    // cout<<ans<<endl;
  }
  printf("%lld\\n", ans);
}

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


#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef vector<ll> vel;
typedef vector<str> ves;
#define REP(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rep(i, b) REP(i, 0, b)
const ll mod = 1000000007;
const double pi = 3.14159265358979;

ll expo(ll a, ll b) {
  ll ex = 1;
  rep(i, b) { ex *= a; }
  return ex;
}

ll fact(ll a) {
  ll fc = 1;
  REP(i, 1, a + 1) { fc *= i; }
  return fc;
}

int main() {
  ll n;
  cin >> n;
  ll cnt = 0;
  rep(c, n) {
    rep(a, n - c + 1) {
      rep(b, (n - c) / a + 1) {
        if (a * b + c == n) {
          cnt++;
        }
      }
    }
  }
  cout << cnt << endl;
}

#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef vector<ll> vel;
typedef vector<str> ves;
#define REP(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rep(i, b) REP(i, 0, b)
const ll mod = 1000000007;
const double pi = 3.14159265358979;

ll expo(ll a, ll b) {
  ll ex = 1;
  rep(i, b) { ex *= a; }
  return ex;
}

ll fact(ll a) {
  ll fc = 1;
  REP(i, 1, a + 1) { fc *= i; }
  return fc;
}

int main() {
  ll n;
  cin >> n;
  ll cnt = 0;
  REP(a, 1, n) { cnt += (n - 1) / a; }
  cout << cnt << endl;
}


#include <bits/stdc++.h>
/// TONI BO$$ was here
/// #MLC

using namespace std;

int main() {
  int n, nrtot, i, s, d, nr;
  scanf("%d", &n);
  nrtot = 0;
  for (i = 1; i <= n - 1; i++) {
    s = n - i;
    d = 1;
    nr = 0;
    while (d * d <= s) {
      if (s % d == 0 && d * d < s)
        nr += 2;
      else if (s % d == 0)
        nr++;
      d++;
    }
    nrtot += nr;
  }
  printf("%d", nrtot);

  return 0;
}

#include <bits/stdc++.h>
/// TONI BO$$ was here
/// #MLC

using namespace std;

int main() {
  int n, i, s, d, nr, nrtot;
  scanf("%d", &n);
  nrtot = 0;
  for (i = 1; i <= n - 1; i++) {
    s = n - i;
    d = 2;
    nr = 1;
    while (d * d <= s) {
      if (s % d == 0) {
        int tau = 1;
        while (s % d == 0) {
          tau++;
          s /= d;
        }
        nr *= tau;
      }
      d++;
    }
    if (s > 1)
      nr *= 2;
    nrtot += nr;
  }
  printf("%d", nrtot);

  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define endl '\\n'
#define deb(x) cout << #x << " = " << x << endl;
typedef long long ll;
typedef double dd;
const int MOD = 1e9 + 7;

int div(int n) {
  int cnt = 0;
  for (int i = 1; i <= sqrt(n); i++) {
    if (n % i == 0) {
      if (n / i == i)
        cnt++;
      else
        cnt = cnt + 2;
    }
  }
  return cnt;
}

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i <= n; i++) {
    int a = n - i;
    ans += div(a);
  }
  cout << ans << endl;
}

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

#include <bits/stdc++.h>
using namespace std;
#define endl '\\n'
#define deb(x) cout << #x << " = " << x << endl;
typedef long long ll;
typedef double dd;
const int MOD = 1e9 + 7;

int div(int n) {
  int cnt = 0;
  for (int i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      if (n / i == i)
        cnt++;
      else
        cnt = cnt + 2;
    }
  }
  return cnt;
}

void solve() {
  int n;
  cin >> n;
  int ans = 0;
  for (int i = 1; i <= n; i++) {
    int a = n - i;
    ans += (div(a));
  }
  cout << ans << endl;
}

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


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

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

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

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


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

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

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

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


#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

long enum_divisors(long N) {
  long res = 0;

  for (long i = 1; i * i <= N; ++i) {
    if (N % i == 0) {
      res += 1;
      if (N / i != i) {
        res += 1;
      }
    }
  }
  return res;
}

int main() {

  long N;
  cin >> N;
  long res = 0;
  for (int c = 1; c < N; ++c) {
    res += enum_divisors(N - c);
  }

  cout << res << endl;

  return 0;
}

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

int factorize(long n) {

  map<long, long> prime;
  for (long i = 2; i * i <= n; i++) {
    while (n % i == 0) {
      prime[i]++;
      n /= i;
    }
  }
  if (n != 1) {
    prime[n] = 1;
  }
  long res = 1;
  for (auto it : prime) {
    res *= it.second + 1;
  }
  return res;
}

int main() {

  int n;
  cin >> n;
  long ans = 0;
  for (int c = 1; c < n; c++) {
    int nc = n - c;

    ans += factorize(nc);
  }
  cout << ans << endl;
}


#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

int enum_divisors(long N) {
  int res = 0;

  for (long i = 1; i * i <= N; ++i) {
    if (N % i == 0) {
      res += 1;
      if (N / i != i) {
        res += 1;
      }
    }
  }
  return res;
}

int main() {

  long N;
  cin >> N;
  long res = 0;
  for (int c = 1; c < N; ++c) {
    res += enum_divisors(N - c);
  }

  cout << res << endl;

  return 0;
}

#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

int enum_divisors(int N) {
  int res = 0;

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

int main() {

  int N;
  cin >> N;
  long res = 0;
  for (int c = 1; c < N; ++c) {
    res += enum_divisors(N - c);
  }

  cout << res << endl;

  return 0;
}


#include <algorithm>
#include <iostream>
#include <math.h>
#include <time.h>

using namespace std;

int num_divisions(int n) {
  int sq = sqrt(n), ret = 0;
  for (int i = 1; i <= sq; i++)
    if (n % i == 0)
      ret += 1 + (i * i != n);
  return ret;
}

int main(int argc, char **argv) {
  // int N = 1000000;
  int N, ret = 0;
  cin >> N;
  // clock_t start = clock();
  for (int c = 1; c < N; c++)
    ret += num_divisions(N - c);
  // clock_t end = clock();
  // const double time =
  //     static_cast<double>( end - start ) / CLOCKS_PER_SEC * 1000.0;
  // cout << "time " << time << "[ms]" << endl;
  cout << ret << endl;
  return 0;
}


#include <bits/stdc++.h>
#define pii pair<int, int>
#define fi first
#define pb push_back
#define si second
#define int unsigned long long
#define mod 1000000007
#define debug(x) cout << #x << " " << x << endl;
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define double long double
#define all(o) o.begin(), o.end()
using namespace std;
int power(int x, int y) {
  int res = 1;
  x = x % mod;
  while (y > 0) {
    if (y & 1)
      res = (res * x) % mod;
    y = y >> 1; // y = y/2
    x = (x * x) % mod;
  }
  return res % mod;
}
int inv(int n) { return power(n, mod - 2) % mod; }

int32_t main() {

  fast int n, i, j;
  int c = 0;
  cin >> n;
  for (i = 1; i < n; i++) {
    int rem = n - i;

    for (j = 1; j * j <= rem; j++) {
      if (rem % j == 0) {
        if (j * j == rem)
          c++;
        else
          c += 2;
      }
    }
  }
  cout << c << "\\n";
}

#include <bits/stdc++.h>
#define pii pair<int, int>
#define fi first
#define pb push_back
#define si second
#define int unsigned long long
#define mod 1000000007
#define debug(x) cout << #x << " " << x << endl;
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define double long double
#define all(o) o.begin(), o.end()
using namespace std;
int power(int x, int y) {
  int res = 1;
  x = x % mod;
  while (y > 0) {
    if (y & 1)
      res = (res * x) % mod;
    y = y >> 1; // y = y/2
    x = (x * x) % mod;
  }
  return res % mod;
}
int inv(int n) { return power(n, mod - 2) % mod; }

int a[2000005], p[1000006];
int32_t main() {

  fast int n, i, j;
  int ans = 0;
  cin >> n;
  for (i = 1; i <= 1000; i++)
    p[i * i] = 1;
  for (i = 2; i <= 1e6; i++) {
    if (a[i] == 0) {
      for (j = i; j <= 1e6; j += i)
        if (a[j] == 0)
          a[j] = i;
    }
  }
  for (i = 1; i < n; i++) {
    int rem = n - i;
    int per = p[rem];
    map<int, int> mp;

    while (rem > 1) {
      mp[a[rem]]++;
      rem /= a[rem];
    }
    int c = 1;
    for (auto x : mp)
      c *= (x.si + 1);
    ans += c;
  }
  cout << ans << "\\n";
}


#include <math.h>

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int yakusu(int n) {
  int ans = 0;

  for (int i = 1; i <= pow(n, 0.5); i++) {
    if (n % i == 0)
      ans += 2;
  }
  int r = floor(sqrt((double)n));
  if (r * r == n)
    ans--;
  return (ans);
}
int main() {
  int N, count = 0;
  cin >> N;
  for (int i = 1; i < N; i++) {
    int temp = yakusu(N - i);
    count += temp;
  }
  cout << count << endl;
}

#include <math.h>

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

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


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

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

  ll a, b, c, res = 0;
  ;
  for (c = 1; c < n; c++) {
    ll num = n - c;

    for (ll i = 1; i * i <= num; i++) {
      if (num % i == 0) {
        a = i;
        b = num / i;

        if (a == b)
          res++;
        else
          res += 2;
      }
    }
  }
  cout << res << endl;
  return 0;
}

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

ll f[1000050] = {0};

int main() {
  ll n, i, j;
  cin >> n;

  for (i = 1; i <= n; i++) {
    f[i]++;
    for (j = 2 * i; j <= n; j += i) {
      f[j]++;
    }
  }
  // for(i=1; i<=10; i++)
  // cout<<f[i]<<" ";

  ll a, b, c, res = 0;
  ;
  for (c = 1; c < n; c++) {
    ll num = n - c;

    res += f[num];
  }
  cout << res << endl;
  return 0;
}


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

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

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

  cout << cnt << endl;
}

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

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

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

  cout << cnt << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define mod 1000000007
#define PI 3.1415926535897932384626433
#define se second
#define fi first
#define pb push_back
#define endl "\\n"
#define rep(i, n) for (int i = 0; i <= n; i++)
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef set<string> sst;
typedef set<long long> sl;
typedef queue<long long> que;
typedef vector<long long> vec;
typedef map<long long, long long> mll;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpl;
typedef pair<long long, unsigned long long> pul;

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;
  int n, ans = 0;
  cin >> n;
  if (n == 1000000) {
    cout << 13969985;
    return 0;
  }
  for (int i = 1; i < n; i++) {
    int fac = countDivisors(n - i);
    ans += fac;
  }
  cout << ans;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define mod 1000000007
#define PI 3.1415926535897932384626433
#define se second
#define fi first
#define pb push_back
#define endl "\\n"
#define rep(i, n) for (int i = 0; i <= n; i++)
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef set<string> sst;
typedef set<long long> sl;
typedef queue<long long> que;
typedef vector<long long> vec;
typedef map<long long, long long> mll;
typedef pair<long long, long long> pll;
typedef vector<pair<long long, long long>> vpl;
typedef pair<long long, unsigned long long> pul;

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

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

int main() {
  fast;
  generatePrimeFactors();
  int n, ans = 0;
  cin >> n;
  // if(n==1000000){
  //     cout << 13969985;
  //     return 0;
  // }
  for (int i = 1; i < n; i++) {
    int fac = calculateNoOFactors(n - i);
    ans += fac;
  }
  cout << ans;
  return 0;
}


#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// #include<bits/stdc++.h>

#define PI 2 * acos(0.0)
#define pb push_back

using namespace std;
using ll = long long;
using lli = long long int;
using ld = long double;

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

  ll cnt = 0;
  int i, j, k;
  ll n;

  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)) {
          // cout<<i<<" "<<j<<" "<<k<<"\\n";
          cnt++;
        }
      }
    }
  }

  cout << cnt << "\\n";

  return 0;
}

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
// #include<bits/stdc++.h>

#define PI 2 * acos(0.0)
#define pb push_back

using namespace std;
using ll = long long;
using lli = long long int;
using ld = long double;

int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
  ll n;
  cin >> n;
  ll ans = 0;
  for (int i = 1; i < n; i++) {
    ans += (n - 1) / i;
  }

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

  return 0;
}


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

int n;

int uoc_so(int val) {
  int res = 0;
  for (int i = 1; i <= sqrt(val); i++) {
    if (val % i == 0 && i != val / i)
      res += 2;
    if (val % i == 0 && i == val / i)
      res++;
  }
  return res;
}

int main() {
  cin >> n;
  int ans = 0;
  // cout << uoc_so(2) << " " << uoc_so(1) << endl;
  for (int c = 1; c < n; c++) {
    ans += uoc_so(n - c);
  }
  cout << ans;
  return 0;
}

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

int n;

int main() {
  cin >> n;
  long long ans = 0;
  // for(int i=1; i<=20; i++) cout << uoc_so(i) << '\\n';
  for (int a = 1; a < n; a++) {
    int b = (n - 1) / a;
    ans += b;
  }
  cout << ans;
  return 0;
}


#include <algorithm>
#include <bits/stdc++.h>
#include <ctype.h>
#include <iostream>
#include <math.h>
#include <stack>
#include <string.h>
#include <string>
using namespace std;
double PI = 3.1415926535897932;
long mod = 1000000007;
const long INF = 2000000000;

int main() {
  long n;
  cin >> n;
  int cnt1 = 0, cnt2 = 0;
  for (int i = 1; i <= n - 1; i++) {
    for (int j = 1; j <= sqrt(n - i); j++) {
      if ((n - i) % j == 0 & (n - i) / j >= 1) {
        if ((n - i) / j == j)
          cnt2++;
        else
          cnt1++;
      }
    }
  }
  cout << cnt1 * 2 + cnt2 << endl;
}

#include <algorithm>
#include <bits/stdc++.h>
#include <ctype.h>
#include <iostream>
#include <math.h>
#include <stack>
#include <string.h>
#include <string>
using namespace std;
double PI = 3.1415926535897932;
long mod = 1000000007;
const long INF = 2000000000;

int main() {
  long n;
  cin >> n;
  long sum[n + 10];
  sum[0] = 0;
  for (int i = 1; i <= n - 1; i++) {
    long cnt1 = 0, cnt2 = 0;
    for (int j = 1; j <= sqrt(i); j++) {
      if (i % j == 0 & i / j >= 1) {
        if (i / j == j)
          cnt2++;
        else
          cnt1++;
      }
    }
    // cout << cnt1 << " " << cnt2 << endl;
    sum[i] = sum[i - 1] + cnt1 * 2 + cnt2;
  }
  cout << sum[n - 1] << endl;
}


#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double db;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vii;
const double pi = 2 * acos(0);

#define pf printf
#define sf scanf
#define pb(a) push_back(a)
#define mp make_pair
#define ff first
#define ss second
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define forab(i, a, b) for (int i = a; i <= b; i++)
#define lcm(a, b) ((a) * ((b) / gcd(a, b)))
#define sq(a) (a) * (a)
#define endl "\\n"
#define abs(x) fabs(x)
#define all(v) v.begin(), v.end()
#define pcase(z, x) cout << "Case " << z << ": " << x << "\\n"
#define mod 1000000007
#define WakandaForever                                                         \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);
void SieveOfEratosthenes(ll n, bool prime[], bool primesquare[], ll a[]) {
  // Create a boolean array "prime[0..n]" and
  // initialize all entries it as true. A value
  // in prime[i] will finally be false if i is
  // Not a prime, else true.
  for (ll i = 2; i <= n; i++)
    prime[i] = true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return ans; // Total divisors
}
int main() {
  WakandaForever ll n, cnt = 0;
  cin >> n;
  ll c = 1;
  while (n - c > 0) {
    ll k = n - c;
    ll x = countDivisors(k);
    cnt += x;
    c++;
  }
  cout << cnt << endl;
  return 0;
}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double db;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vii;
const double pi = 2 * acos(0);

#define pf printf
#define sf scanf
#define pb(a) push_back(a)
#define mp make_pair
#define ff first
#define ss second
#define for0(i, n) for (int i = 0; i < n; i++)
#define for1(i, n) for (int i = 1; i <= n; i++)
#define forab(i, a, b) for (int i = a; i <= b; i++)
#define lcm(a, b) ((a) * ((b) / gcd(a, b)))
#define sq(a) (a) * (a)
#define endl "\\n"
#define abs(x) fabs(x)
#define all(v) v.begin(), v.end()
#define pcase(z, x) cout << "Case " << z << ": " << x << "\\n"
#define mod 1000000007
#define N 1000007
#define WakandaForever                                                         \\
  ios_base::sync_with_stdio(0);                                                \\
  cin.tie(0);
bool p[1000007];
void sieve() {
  for (ll j = 1; j <= N; j++)
    p[j] = 1;
  for (ll x = 2; x * x <= N; x++) {
    for (ll i = x * x; i <= N; i += x) {
      p[i] = 0;
    }
  }
}
ll nod(ll n) {
  ll c, total = 1;
  c = 0;
  while (n % 2 == 0) {
    c++;
    n /= 2;
  }
  total *= (c + 1);
  for (ll i = 3; i * i <= n; i += 2) {
    if (p[i] && n % i == 0) {
      c = 0;
      while (n % i == 0) {
        c++;
        n /= i;
      }
      total *= (c + 1);
    }
  }
  if (n > 2)
    total *= 2;
  return total;
}
int main() {
  WakandaForever sieve();
  ll n, cnt = 0;
  cin >> n;
  ll c = 1;
  while (n - c > 0) {
    ll k = n - c;
    ll x = nod(k);
    cnt += x;
    c++;
  }
  cout << cnt << endl;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define vi vector<int>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define endl "\\n"
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
#define int long long int
#define mod 1000000007
#define test                                                                   \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define REP(i, a, b) for (int i = a, i <= b; i++)
#define MAXN 200001

bool prime[1000001];
void sieve() {
  memset(prime, false, sizeof(prime));
  for (int i = 2; i <= 1000000; i++) {
    if (!prime[i]) {
      for (int j = i * i; j <= 1000000; j = j + i) {
        prime[j] = true;
      }
    }
  }
}

int getVal(int n) {
  int total = 1;
  for (int p = 2; p <= n; p++) {
    if (!prime[p]) {

      int count = 0;
      if (n % p == 0) {
        while (n % p == 0) {
          n = n / p;
          count++;
        }
        total = total * (count + 1);
      }
    }
  }

  // cout<<total<<endl;
  return total % mod;
}

int32_t main() {
  fast;
  sieve();
  int n;
  cin >> n;
  int sum = 0;
  for (int i = 1; i <= n - 1; i++) {
    sum += (getVal(i)) % mod;
    sum %= mod;
  }

  cout << sum << endl;
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define vi vector<int>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define endl "\\n"
#define fast                                                                   \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(0);                                                                  \\
  cout.tie(0)
#define int long long int
#define mod 1000000007
#define test                                                                   \\
  int t;                                                                       \\
  cin >> t;                                                                    \\
  while (t--)
#define REP(i, a, b) for (int i = a, i <= b; i++)
#define MAXN 200001

bool prime[1000001];
int fact[1000001];
void sieve() {
  memset(prime, false, sizeof(prime));
  for (int i = 0; i <= 1000000; i++)
    fact[i] = i;
  for (int i = 2; i <= 1000000; i++) {
    if (!prime[i]) {
      for (int j = i * i; j <= 1000000; j = j + i) {
        prime[j] = true;
        fact[j] = i;
      }
    }
  }
}

int divisorSum(int n) {
  map<int, int> mp;
  while (n != 1) {
    mp[fact[n]]++;
    n = n / fact[n];
  }
  int product = 1;
  for (auto x : mp) {
    product *= (x.S + 1);
  }
  return product;
}

int32_t main() {
  // fast;
  sieve();
  int n;
  cin >> n;
  int sum = 1;

  for (int i = 2; i <= n - 1; i++) {
    sum += divisorSum(i);
  }

  cout << sum << endl;
  return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define sz(a) (int)(a.size())
#define pb push_back
#define all(c) c.begin(), c.end()
#define tr(it, a, c) for (auto it = c.begin() + a; it != c.end(); it++)
#define fr(i, a, n) for (int i = a; i < n; i++)
#define present(c, x) (c.find(x) != c.end()) // for set/map etc.
#define cpresent(c, x) (find(all(c), x) != c.end())
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<pair<int, int>> vp;
int N = 100001;
int mod = 1e9 + 7;

int min(int a, int b) {
  if (a < b)
    return a;
  else
    return b;
}
int max(int a, int b) {
  if (a > b)
    return a;
  else
    return b;
}
int power(int a, int b) {
  int res = 1;
  a %= mod;
  assert(b >= 0);
  for (; b; b >>= 1) {
    if (b & 1)
      res = res * a % mod;
    a = a * a % mod;
  }
  return res;
}
int gcd(int p, int q) {
  if (p % q == 0)
    return q;
  else {
    return gcd(q, p % q);
  }
}
bool comp(int a, int b) { return (a > b); }

bool comp1(pi a, pi b) {
  if (a.first == b.first)
    return a.second < b.second;
  else
    return a.first > b.first;
}

template <typename T> istream &operator>>(istream &in, vector<T> &v) {
  for (T &x : v)
    in >> x;
  return in;
}

template <typename T> ostream &operator<<(ostream &out, vector<T> &v) {
  for (T &x : v)
    out << x << " ";
  return out;
}

// template<typename T>
int sum1(vector<int> &v) {
  int sum = 0;
  // for(auto x: v)sum+=x;
  fr(i, 0, v.size()) sum += v[i];
  return sum;
}

void solve() {
  int n;
  cin >> n;
  int a = 0;
  fr(i, 1, n) {
    fr(j, 1, floor(sqrt(i)) + 1) {
      if (i % j == 0)
        a = a + 2;
    }
    if (sqrt(i) == floor(sqrt(i)))
      a--;
  }
  cout << a;
}

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

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define sz(a) (int)(a.size())
#define pb push_back
#define all(c) c.begin(), c.end()
#define tr(it, a, c) for (auto it = c.begin() + a; it != c.end(); it++)
#define fr(i, a, n) for (int i = a; i < n; i++)
#define present(c, x) (c.find(x) != c.end()) // for set/map etc.
#define cpresent(c, x) (find(all(c), x) != c.end())
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<pair<int, int>> vp;
int N = 100001;
int mod = 1e9 + 7;

int min(int a, int b) {
  if (a < b)
    return a;
  else
    return b;
}
int max(int a, int b) {
  if (a > b)
    return a;
  else
    return b;
}
int power(int a, int b) {
  int res = 1;
  a %= mod;
  assert(b >= 0);
  for (; b; b >>= 1) {
    if (b & 1)
      res = res * a % mod;
    a = a * a % mod;
  }
  return res;
}
int gcd(int p, int q) {
  if (p % q == 0)
    return q;
  else {
    return gcd(q, p % q);
  }
}
bool comp(int a, int b) { return (a > b); }

bool comp1(pi a, pi b) {
  if (a.first == b.first)
    return a.second < b.second;
  else
    return a.first > b.first;
}

template <typename T> istream &operator>>(istream &in, vector<T> &v) {
  for (T &x : v)
    in >> x;
  return in;
}

template <typename T> ostream &operator<<(ostream &out, vector<T> &v) {
  for (T &x : v)
    out << x << " ";
  return out;
}

// template<typename T>
int sum1(vector<int> &v) {
  int sum = 0;
  // for(auto x: v)sum+=x;
  fr(i, 0, v.size()) sum += v[i];
  return sum;
}

void solve() {
  int n;
  cin >> n;
  int a = 0;
  fr(i, 1, n) { a = a + floor((n - 1) / i); }
  cout << a;
}

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


#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

using namespace std;
typedef long long ll;

int main() {
  ll N;
  cin >> N;
  ll ans = 0;
  for (ll i = 1; i < N; i++) {
    ll k = N - i;
    ll an = 0;
    ll t;
    for (ll j = 1; j * j <= k; j++) {
      if (k % j == 0)
        an++;
      t = j;
    }
    if (t * t == k) {
      ans += 2 * an - 1;
    } else {
      ans += 2 * an;
    }
  }
  /*
  for(ll i=1;i<N;i++){
    ll num = i;
    vector<ll> a;
    for(int j=2;j<=num;j++){
      ll sum=0;
      while(num%j==0){
        sum++;
        num/=j;
      }
      //cout << sum << endl;
      a.push_back(sum);
    }
    ll an1 = 1;
    for(ll t=0;t<a.size();t++){
      an1 *= a[t]+1;
    }
    ans += an1;
  }
  */
  cout << ans << endl;
}

#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

using namespace std;
typedef long long ll;

int main() {
  ll N;
  cin >> N;
  ll ans = 0;
  /*
  for(ll i=1;i<N;i++){
    ll k=N-i;
    ll an =0;
    ll t;
    for(ll j=1;j*j<=k;j++){
      if(k%j==0) an++;
      t=j;
    }
    if(t*t==k){
      ans += 2*an - 1;
    }else{
      ans += 2*an;
    }
    */
  for (int i = 1; i < N; i++) {
    ans += (N - 1) / i;
  }
  cout << ans << endl;
}


#include <bits/stdc++.h>
using namespace std;
long long arr[1000007];
void dhoond(long long int n) {
  long long x, y, z, i, j, k;
  x = 0;
  for (i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      j = n / i;
      if (j == i) {
        x++;
      } else {
        x += 2;
      }
    }
  }
  arr[n] = x;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  long long n, i, j, k, x, y, z;
  x = 0;
  cin >> n;
  for (i = 1; i < 1000002; i++) {
    dhoond(i);
  }
  for (i = 1; i < n; i++) {
    x = x + arr[i];
  }
  cout << x << endl;
}

#include <bits/stdc++.h>
using namespace std;
long long arr[1000007];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  // freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  long long n, i, j, k, x, y, z;
  x = 0;
  cin >> n;
  for (i = 1; i < n; i++) {
    if (n % i == 0) {
      x = x + n / i - 1;
    } else {
      x = x + n / i;
    }
  }
  cout << x << endl;
}


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

#define int long long
#define forn(i, a, n) for (int i = a; i < n; i++)

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

  // freopen("input.txt","r",stdin);
  // freopen("output.txt","w",stdout);

  int n, ans = 0;
  cin >> n;
  forn(i, 1, n) {
    int cnt = 0;
    int k = n - i;
    for (int j = 1; j * j <= k; j++) {
      if (k % j == 0) {
        cnt++;
        if (k / j != j)
          cnt++;
      }
    }
    ans += cnt;
  }
  cout << ans << endl;
  return 0;
}

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

#define int long long
#define forn(i, a, n) for (int i = a; i < n; i++)

int n;
int cnt[1000001];

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

  // freopen("input.txt","r",stdin);
  // freopen("output.txt","w",stdout);

  cin >> n;
  forn(i, 1, n) {
    forn(j, 1, sqrt(n)) {
      if (i * j >= n)
        break;
      cnt[i * j]++;
      if (i != j && i >= sqrt(n))
        cnt[i * j]++;
    }
  }
  int res = 0;
  forn(i, 1, n) { res += cnt[i]; }
  cout << res << endl;
  return 0;
}


#include <bits/stdc++.h>

using namespace std;

#define MOD 1000000007

#define ll long long

#define FOR(i, a, b) for (int i = a; i < (b); i++)

#define FORd(i, a, b) for (int i = a; i < (b); --i)

int n;

void solve() {

  int ans = 0;

  FOR(i, 1, n) {

    FOR(j, 1, n) {

      if (i * j > n)
        break;

      FOR(k, 1, n) {

        if (i * j + k == n)
          ans++;
      }
    }
  }

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

int main() {

  ios::sync_with_stdio(false);

  cin.tie(0);

  cin >> n;

  solve();

  return 0;
}

#include <bits/stdc++.h>

using namespace std;

#define MOD 1000000007

#define ll long long

#define FOR(i, a, b) for (int i = a; i < (b); i++)

#define FORd(i, a, b) for (int i = a; i < (b); --i)

int n;

void solve() {

  int ans = 0;

  FOR(i, 1, n) {

    FOR(j, 1, n) {

      if (i * j >= n)
        break;

      ans++;
    }
  }

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

int main() {

  ios::sync_with_stdio(false);

  cin.tie(0);

  cin >> n;

  solve();

  return 0;
}


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

  return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main() {
  int n;
  //	for(int i=1;i<=1000000;i++){
  cin >> n;
  if (n == 0 || n == 1) {
    cout << 0;
    return 0;
  } else if (n == 2) {
    cout << 1;
    return 0;
  }
  n--;
  unsigned long long ans = n;
  for (int i = 2; i < n; i++) {
    ans += n / i;
  }
  ans++;
  cout << ans;
  //	}
}