output_description: Print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
attempt: # Python3 program to count
  # number of factors
  # of an array of integers
  MAX = 1000005
  
  # array to store
  # prime factors
  factor = [0] * (MAX + 1)
  
  # function to generate all
  # prime factors of numbers
  # from 1 to 10^6
  
  
  def generatePrimeFactors():
      factor[1] = 1
  
      # Initializes all the
      # positions with their value.
      for i in range(2, MAX):
          factor[i] = i
  
      # Initializes all
      # multiples of 2 with 2
      for i in range(4, MAX, 2):
          factor[i] = 2
  
      # A modified version of
      # Sieve of Eratosthenes
      # to store the smallest
      # prime factor that divides
      # every number.
      i = 3
      while i * i < MAX:
          # check if it has
          # no prime factor.
          if factor[i] == i:
              # Initializes of j
              # starting from i*i
              j = i * i
              while j < MAX:
                  # if it has no prime factor
                  # before, then stores the
                  # smallest prime divisor
                  if factor[j] == j:
                      factor[j] = i
                  j += i
          i += 1
  
  
  # function to calculate
  # number of factors
  
  
  def calculateNoOFactors(n):
      if n == 1:
          return 1
      ans = 1
  
      # stores the smallest
      # prime number that
      # divides n
      dup = factor[n]
  
      # stores the count of
      # number of times a
      # prime number divides n.
      c = 1
  
      # reduces to the next
      # number after prime
      # factorization of n
      j = int(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 = int(j / factor[j])
  
      # for the last
      # prime factor
      ans = ans * (c + 1)
  
      return ans
  
  
  # Driver Code
  
  
  if __name__ == "__main__":
  
      # generate prime factors
      # of number upto 10^6
      generatePrimeFactors()
      # a = [10, 30, 100, 450, 987]
      # q = len(a)
      s = 0
      for i in range(1, int(input())):
          s += calculateNoOFactors(i)
      print(s)
  
  # This code is contributed
  # by mits.
  
problem_description: Statement
  
  Given is a positive integer N. How many tuples (A,B,C) of positive integers
  satisfy A \times B + C = N?
samples: [{"input": "3", "output": "3\n    \n\nThere are 3 tuples of integers that satisfy A \\times B + C = 3: (A, B, C) =\n(1, 1, 2), (1, 2, 1), (2, 1, 1).\n\n* * *"}, {"input": "100", "output": "473\n    \n\n* * *"}, {"input": "1000000", "output": "13969985"}]