



def  _snake_case			(							__snake_case = 1_0_0_0     )  ->  int:






      '''simple docstring'''







      UpperCAmelCase_	:						Optional[int]					   =		[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)
      UpperCAmelCase_	:						Optional[int]					   =		[0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

      UpperCAmelCase_	:						Union[str, Any]					   =		0

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

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

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


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





import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute







def  _snake_case			(							__snake_case = 1       ,	__snake_case = 1     )  ->  qiskit.result.counts.Counts:






      '''simple docstring'''







      if isinstance(__snake_case       ,	__snake_case     ) or isinstance(__snake_case       ,	__snake_case     ):
            raise TypeError("inputs must be integers."     )
      if (bit_a < 0) or (bit_a < 0):
            raise ValueError("inputs must be positive."     )
      if (math.floor(__snake_case     ) != bit_a) or (math.floor(__snake_case     ) != bit_a):
            raise ValueError("inputs must be exact integers."     )
      if (bit_a > 1) or (bit_a > 1):
            raise ValueError("inputs must be less or equal to 1."     )

      # build registers
      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumRegister(2       ,	"qr"     )
      UpperCAmelCase_	:						Tuple					   =		ClassicalRegister(2       ,	"cr"     )

      UpperCAmelCase_	:						Union[str, Any]					   =		QuantumCircuit(__snake_case       ,	__snake_case     )

      # entanglement the qubits
      quantum_circuit.h(1     )
      quantum_circuit.cx(1       ,	0     )

      # send the information
      UpperCAmelCase_	:						Any					   =		str(__snake_case     ) + str(__snake_case     )

      if c_information == "11":
            quantum_circuit.x(1     )
            quantum_circuit.z(1     )
      elif c_information == "10":
            quantum_circuit.z(1     )
      elif c_information == "01":
            quantum_circuit.x(1     )
      else:
            quantum_circuit.i(1     )

      # unentangled the circuit
      quantum_circuit.cx(1       ,	0     )
      quantum_circuit.h(1     )

      # measure the circuit
      quantum_circuit.measure(__snake_case       ,	__snake_case     )

      UpperCAmelCase_	:						Union[str, Any]					   =		Aer.get_backend("aer_simulator"     )
      UpperCAmelCase_	:						Dict					   =		execute(__snake_case       ,	__snake_case       ,	shots=1_0_0_0     )

      return job.result().get_counts(__snake_case     )


if __name__ == "__main__":
   print(F'''Counts for classical state send: {superdense_coding(1,1)}''')
