


import math

class 							a						:




							"""simple docstring"""


							def        __snake_case   (				self			:    List[Any]       ,      lowerCamelCase			:    list[list[float]]       ,      lowerCamelCase			:    list[int]							)      ->       int:
														__snake_case						:     Optional[int]									=  0.0
														__snake_case						:     int									=  0.0
														for i in range(len(__UpperCamelCase							)							):
																					da += math.pow((sample[i] - weights[0][i])       ,      2							)
																					da += math.pow((sample[i] - weights[1][i])       ,      2							)
																					return 0 if da > da else 1
														return 0






							def        __snake_case   (				self			:    Dict       ,      lowerCamelCase			:    list[list[int | float]]       ,      lowerCamelCase			:    list[int]       ,      lowerCamelCase			:    int       ,      lowerCamelCase			:    float							)      ->       list[list[int | float]]:






														for i in range(len(__UpperCamelCase							)							):
																					weights[j][i] += alpha * (sample[i] - weights[j][i])
														return weights







def 							lowerCAmelCase_	(   ):
							__snake_case						:     Optional[int]									=  [[1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 1]]

							# weight initialization ( n, C )
							__snake_case						:     str									=  [[0.2, 0.6, 0.5, 0.9], [0.8, 0.4, 0.7, 0.3]]

							# training
							__snake_case						:     Dict									=  SelfOrganizingMap()
							__snake_case						:     str									=  3
							__snake_case						:     str									=  0.5

							for _ in range(_A      ):
														for j in range(len(_A      )      ):
																					# training sample
																					__snake_case						:     Tuple									=  training_samples[j]

																					# Compute the winning vector
																					__snake_case						:     Dict									=  self_organizing_map.get_winner(_A				,      _A      )

																					# Update the winning vector
																					__snake_case						:     int									=  self_organizing_map.update(_A				,      _A				,      _A				,      _A      )

    # classify test sample
							__snake_case						:     str									=  [0, 0, 0, 1]
							__snake_case						:     List[Any]									=  self_organizing_map.get_winner(_A				,      _A      )

							# results
							print(F'Clusters that the test sample belongs to : {winner}'      )
							print(F'Weights that have been trained : {weights}'      )


# running the main() function
if __name__ == "__main__":
			main()



"""simple docstring"""



def 			_UpperCamelCase						(    _A = 1_0_0_0   )     ->	int:





    """simple docstring"""

    _UpperCAmelCase     ,_UpperCAmelCase        = 1, 1
    _UpperCAmelCase        = 2
    while True:
        _UpperCAmelCase        = 0
        _UpperCAmelCase        = fa + fa
        _UpperCAmelCase     ,_UpperCAmelCase        = fa, f
        index += 1
        for _ in str(_A   ):
            i += 1
        if i == n:
            break
    return index


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