#include <iostream>
#include <climits>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
 
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

#define MOD 1000000007LL

ll C(int, int);
int xgcd(int, int, int &, int &);
int gcd(int, int);
int modinv(int, int);
ll modInverse(ll, ll);
ll power(ll, ll, ll);

ll pow2(int);

/*
  nCkを求める
  MOD(1000000007LL)で割った余りを算出
  */
ll C(int n, int k) {
  ll ret=1;
  int i;
  int a, b;

  a = k;
  b = n-k;
  if (a<b) swap(a,b);

  for (i=n; i>a; i--) {
    ret *= i;
    ret %= MOD;
  }
  for (i=2; i<=b; i++) {
    ret *= modinv(i, MOD);
    ret %= MOD;
  }
  return ret;
}
/*
  n個から重複を許してk個選択する組合せ
  */
ll H(int n, int k) {
  ll ret;
  ret = C(n+k-1, k);
//printf("dC(%d, %d) = %lld\n", n, k, ret);
  return ret;
}


//素数判定
vector<int> pr={2,3,5,7};
#define MAX_PRIME 1000000

bool isprime(int n) {
  int i;
  int prime(int);
  if (n>MAX_PRIME) return true;
  int sz=pr.size();
  int sq = sqrt(n);
  for (i=1; i<sz; i++) {
    int p=pr[i];
    if (p>sq) return true;
    if (n%p==0) return false;
  }
  for (;;i++) {
    int p=prime(i);
    if (p>sq) return true;
    if (n%p==0) return false;
  }
}

//素数生成
int prime(int n) {
  int last = pr.size();
  if (n<last) return pr[n];

  for (int p=pr.back()+2; last <= n; p+=2) {
    if (isprime(p)) {
      last++;
      pr.push_back(p);
    }
  }
  return pr.back();
}


//素因数分解
//引数の整数を素因数分解する。
//mapクラスのキーに基数、対応する値に指数が入っている
map<ll, int> lc;
map<ll, int> fact(ll n) {
  map<ll, int> ret;
  ll base;
  int ix;

  int i;
  for (i=0; n>1; i++) {
    base = prime(i);
    ix = 0;
    while (n%base == 0) {
      ix++;
      n /= base;
    }
    if (ix > 0) {
      ret[base] = ix;
      auto itr = lc.find(base);
      if (itr == lc.end()) {
        lc[base] = ix;
      } else {
        lc[base] = max(ix, lc[base]);
      }
    } else {
      if (base * base >= n) {
        ret[n] = 1;
        auto itr = lc.find(n);
        if (itr == lc.end()) {
          lc[n] = 1;
        } else {
          lc[n] = max(1, lc[n]);
        }
        break;
      }
    }
  }
  return ret;
}

// 最大公約数
// 素因数分解された値での最大公約数算出
map<int, int> lcm(map<int, int> m, map<int, int> n) {
  map<int, int> ret;

  for (auto itm=m.begin(); itm!=m.end(); itm++) {
    auto itn = n.find(itm->first);
    if (itn == n.end()) {
      ret[itm->first] = itm->second;
    } else {
      ret[itm->first] = max(itm->second, itn->second);
      n.erase(itm->first);
    }
  }
  for (auto itn=n.begin(); itn!=n.end(); itn++) {
    ret[itn->first] = itn->second;
  }

  return ret;
}

//除算
// 素因数分解された値の除算
map<int, int> vdiv(map<int,int> m, map<int, int> n) {
  map<int, int> ret;

  for (auto itm=m.begin(); itm!=m.end(); itm++) {
    auto itn = n.find(itm->first);
    if (itn == n.end()) {
      ret[itm->first] = itm->second;
    } else {
      ret[itm->first] = itm->second - itn->second;
      n.erase(itm->first);
    }
  }
  for (auto itn=n.begin(); itn!=n.end(); itn++) {
    ret[itn->first] = -itn->second;
  }
  return ret;
}
//modの剰余として、素因数分解したものをint型に変換する
int toInt(map<int, int> f, int m) {
  ll lret=1;

  for (auto itr=f.begin(); itr != f.end(); itr++) {
    for (int j=0; j<itr->second; j++) {
      lret *= itr->first;
      lret %= m;
    }
  }
  return lret;
}

//最大公約数 ユークリッド互除法
int gcd(int m, int n) {
  if (m<n) swap(m, n);
  while (m%n) {
    m%=n;
    swap(m, n);
  }
  return n;
}
//最大公約数 拡張ユークリッド互除法
int xgcd(int a, int b, int &x0, int &y0) {
  x0=1, y0=0;
  int x1=0, y1=1;
  int q;
  int at, x0t, y0t;
  while (b != 0) {
    q = a/b;
    at = b;
    b = a%b;
    a = at;
    x0t = x1;
    x1 = x0-q*x1;
    x0 = x0t;
    y0t = y1;
    y1 = y0-q*y1;
    y0 = y0t;
  }
  return a;
}
ll xgcd(ll a, ll b, ll &x0, ll &y0) {
  x0=1, y0=0;
  ll x1=0, y1=1;
  ll q;
  ll at, x0t, y0t;
  while (b != 0) {
    q = a/b;
    at = b;
    b = a%b;
    a = at;
    x0t = x1;
    x1 = x0-q*x1;
    x0 = x0t;
    y0t = y1;
    y1 = y0-q*y1;
    y0 = y0t;
  }
  return a;
}
//モジュラー逆数
//((ab mod n)(b^-1 mod n)) mod n = a mod n となる aを求めるのに使う
//ab mod n と b mod nがわかっているときに a mod n を算出するため
//modInverseは実績ありmodinvは不明
int modinv(int a, int m) {
  int g, x, y;
  g = xgcd(a, m, x, y);
  if (g != 1) return -1;
  x %= m;
  if (x<0) x+=m;
  return x;
}
ll modinv(ll a, ll m) {
  ll g, x, y;
  g = xgcd(a, m, x, y);
  if (g != 1) return -1;
  x %= m;
  if (x<0) x+=m;
  return x;
}
ll power(ll x, ll y, ll p) {
  ll res = 1;
  x=x%p;
  while (y>0) {
    if (y&1) res = (res*x)%p;
    y = y>>1;
    x = (x*x) %p;
  }
  return res;
}
ll modInverse(ll a, ll m) {
  ll ans = power(a, m-2, m);
  return ans;
}

ll pow2(int n) {
  ll ret=1;
  ll r2=2;
  int i;

  for (i=n; i>0; i/=2) {
    if (i%2) ret *= r2;
    ret %= MOD;
    r2 *= r2;
    r2 %= MOD;

  }
  return ret;
}


struct mint {
  ll x; // typedef long long ll;
  mint(ll x=0):x((x%MOD+MOD)%MOD){}
  mint operator-() const { return mint(-x);}
  mint& operator+=(const mint a) {
    if ((x += a.x) >= MOD) x -= MOD;
    return *this;
  }
  mint& operator-=(const mint a) {
    if ((x += MOD-a.x) >= MOD) x -= MOD;
    return *this;
  }
  mint& operator*=(const mint a) { (x *= a.x) %= MOD; return *this;}
  mint operator+(const mint a) const { return mint(*this) += a;}
  mint operator-(const mint a) const { return mint(*this) -= a;}
  mint operator*(const mint a) const { return mint(*this) *= a;}
  mint pow(ll t) const {
    if (!t) return 1;
    mint a = pow(t>>1);
    a *= a;
    if (t&1) a *= *this;
    return a;
  }
 
  // for prime MOD
  mint inv() const { return pow(MOD-2);}
  mint& operator/=(const mint a) { return *this *= a.inv();}
  mint operator/(const mint a) const { return mint(*this) /= a;}
};

int N;

/*
int nn(int n) {
  int ret=1;
  map<ll, int> lx;
  lx = fact(n);
  for (auto it=lx.begin(); it!=lx.end(); it++) {
    ret *= it->second+1;
//    printf("%lld^%d ", it->first, it->second);
  }
//  printf("%d\n", ret);
  return ret;
}
  */

int nn(int n) {
  int i;
  int ret=0;
  for (i=1; i*i<n; i++) {
    if (n%i == 0) ret++;
  }
  ret *= 2;
  if (i*i==n) ret++;
  return ret;
}

int main()
{
  ll ans=0;
  int C;
//  int A,B,C;

  cin >> N;

  for (C=1; C<N; C++) {
    ans += nn(N-C);
  }
  cout << ans << endl;
  return 0;
}


Measured memory_bytes: 3724