


def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   )->    tuple[list[list[int]], list[list[str]]]:




      """simple docstring"""

      snake_case_			= list(SCREAMING_SNAKE_CASE   )
      snake_case_			= list(SCREAMING_SNAKE_CASE   )
      snake_case_			= len(SCREAMING_SNAKE_CASE   )
      snake_case_			= len(SCREAMING_SNAKE_CASE   )

      snake_case_			= [
          [0 for _ in range(len_destination_seq + 1   )] for _ in range(len_source_seq + 1   )
      ]
      snake_case_			= [
          ['''0''' for _ in range(len_destination_seq + 1   )] for _ in range(len_source_seq + 1   )
      ]

      for i in range(1   ,   len_source_seq + 1   ):
            snake_case_			= i * delete_cost
            snake_case_			= f'''D{source_seq[i - 1]:c}'''

      for i in range(1   ,   len_destination_seq + 1   ):
            snake_case_			= i * insert_cost
            snake_case_			= f'''I{destination_seq[i - 1]:c}'''

      for i in range(1   ,   len_source_seq + 1   ):
            for j in range(1   ,   len_destination_seq + 1   ):
                  if source_seq[i - 1] == destination_seq[j - 1]:
                        snake_case_			= costs[i - 1][j - 1] + copy_cost
                        snake_case_			= f'''C{source_seq[i - 1]:c}'''
                  else:
                        snake_case_			= costs[i - 1][j - 1] + replace_cost
                        snake_case_			= f'''R{source_seq[i - 1]:c}''' + str(destination_seq[j - 1]   )

                  if costs[i - 1][j] + delete_cost < costs[i][j]:
                        snake_case_			= costs[i - 1][j] + delete_cost
                        snake_case_			= f'''D{source_seq[i - 1]:c}'''

                  if costs[i][j - 1] + insert_cost < costs[i][j]:
                        snake_case_			= costs[i][j - 1] + insert_cost
                        snake_case_			= f'''I{destination_seq[j - 1]:c}'''

      return costs, ops






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )->    list[str]:




      """simple docstring"""

      if i == 0 and j == 0:
            return []
      else:
            if ops[i][j][0] == "C" or ops[i][j][0] == "R":
                  snake_case_			= assemble_transformation(SCREAMING_SNAKE_CASE   ,   i - 1   ,   j - 1   )
                  seq.append(ops[i][j]   )
                  return seq
            elif ops[i][j][0] == "D":
                  snake_case_			= assemble_transformation(SCREAMING_SNAKE_CASE   ,   i - 1   ,   SCREAMING_SNAKE_CASE   )
                  seq.append(ops[i][j]   )
                  return seq
            else:
                  snake_case_			= assemble_transformation(SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   ,   j - 1   )
                  seq.append(ops[i][j]   )
                  return seq


if __name__ == "__main__":
   UpperCAmelCase,				UpperCAmelCase     =       compute_transform_tables("""Python""", """Algorithms""", -1, 1, 2, 2)

   UpperCAmelCase     =       len(operations)
   UpperCAmelCase     =       len(operations[0])
   UpperCAmelCase     =       assemble_transformation(operations, m - 1, n - 1)

   UpperCAmelCase     =       list("""Python""")
   UpperCAmelCase     =       0
   UpperCAmelCase     =       0

   with open("""min_cost.txt""", """w""") as file:
      for op in sequence:
         print("""""".join(string))

         if op[0] == "C":
            file.write("""%-16s""" % """Copy %c""" % op[1])
            file.write("""\t\t\t""" + """""".join(string))
            file.write("""\r\n""")

            cost -= 1
         elif op[0] == "R":
            UpperCAmelCase     =       op[2]

            file.write("""%-16s""" % ("""Replace %c""" % op[1] + """ with """ + str(op[2])))
            file.write("""\t\t""" + """""".join(string))
            file.write("""\r\n""")

            cost += 1
         elif op[0] == "D":
            string.pop(i)

            file.write("""%-16s""" % """Delete %c""" % op[1])
            file.write("""\t\t\t""" + """""".join(string))
            file.write("""\r\n""")

            cost += 2
         else:
            string.insert(i, op[1])

            file.write("""%-16s""" % """Insert %c""" % op[1])
            file.write("""\t\t\t""" + """""".join(string))
            file.write("""\r\n""")

            cost += 2

         i += 1

      print("""""".join(string))
      print("""Cost: """, cost)

      file.write("""\r\nMinimum cost: """ + str(cost))



def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE = 1000   )->    int:




      """simple docstring"""

      snake_case_			= [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8]
      # number of letters in twenty, thirty, ..., ninety (0 for numbers less than
      # 20 due to inconsistency in teens)
      snake_case_			= [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

      snake_case_			= 0

      for i in range(1   ,   n + 1   ):
            if i < 1000:
                  if i >= 100:
                        # add number of letters for "n hundred"
                        count += ones_counts[i // 100] + 7

                        if i % 100 != 0:
                              # add number of letters for "and" if number is not multiple
                              # of 100
                              count += 3

                  if 0 < i % 100 < 20:
                        # add number of letters for one, two, three, ..., nineteen
                        # (could be combined with below if not for inconsistency in
                        # teens)
                        count += ones_counts[i % 100]
                  else:
                        # add number of letters for twenty, twenty one, ..., ninety
                        # nine
                        count += ones_counts[i % 10]
                        count += tens_counts[(i % 100 - i % 10) // 10]
            else:
                  count += ones_counts[i // 1000] + 8
      return count


if __name__ == "__main__":
   print(solution(int(input().strip())))