





from __future__ import annotations

from math import pi
from typing import Protocol

import matplotlib.pyplot as plt
import numpy as np






class        _a(    __A    ):







		def        lowercase       (    self ,						__snake_case				)      ->      float:


							'''simple docstring'''

							return 0.0







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					_snake_case       :					List[Any]				       =   min([-20, np.min(fft_results[1 : samplerate // 2 - 1]				)]				)
					_snake_case       :					Dict				       =   max([20, np.max(fft_results[1 : samplerate // 2 - 1]				)]				)
					return lowest, highest







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					_snake_case       :					Optional[Any]				       =   512
					_snake_case       :					str				       =   [1] + [0] * (size - 1)
					_snake_case       :					Optional[Any]				       =   [filter_type.process(UpperCAmelCase				) for item in inputs]

					_snake_case       :					Union[str, Any]				       =   [0] * (samplerate - size)  # zero-padding
					outputs += filler
					_snake_case       :					Optional[int]				       =   np.abs(np.fft.fft(UpperCAmelCase				)				)
					_snake_case       :					Tuple				       =   20 * np.logaa(UpperCAmelCase				)

					# Frequencies on log scale from 24 to nyquist frequency
					plt.xlim(24  ,  samplerate / 2 - 1				)
					plt.xlabel("Frequency (Hz)"				)
					plt.xscale("log"				)

					# Display within reasonable bounds
					_snake_case       :					Any				       =   get_bounds(UpperCAmelCase  ,  UpperCAmelCase				)
					plt.ylim(max([-80, bounds[0]]				)  ,  min([80, bounds[1]]				)				)
					plt.ylabel("Gain (dB)"				)

					plt.plot(UpperCAmelCase				)
					plt.show()







def    A				(							UpperCAmelCase  ,  UpperCAmelCase				):
					_snake_case       :					Optional[Any]				       =   512
					_snake_case       :					Any				       =   [1] + [0] * (size - 1)
					_snake_case       :					Optional[int]				       =   [filter_type.process(UpperCAmelCase				) for item in inputs]

					_snake_case       :					Optional[Any]				       =   [0] * (samplerate - size)  # zero-padding
					outputs += filler
					_snake_case       :					Optional[Any]				       =   np.angle(np.fft.fft(UpperCAmelCase				)				)

					# Frequencies on log scale from 24 to nyquist frequency
					plt.xlim(24  ,  samplerate / 2 - 1				)
					plt.xlabel("Frequency (Hz)"				)
					plt.xscale("log"				)

					plt.ylim(-2 * pi  ,  2 * pi				)
					plt.ylabel("Phase shift (Radians)"				)
					plt.plot(np.unwrap(UpperCAmelCase  ,  -2 * pi				)				)
					plt.show()






def    A				(							UpperCAmelCase				):
					if n == 1 or not isinstance(UpperCAmelCase  ,  UpperCAmelCase				):
										return 0
					elif n == 2:
										return 1
					else:
										_snake_case       :					List[Any]				       =   [0, 1]
										for i in range(2  ,  n + 1				):
															sequence.append(sequence[i - 1] + sequence[i - 2]				)

										return sequence[n]







def    A				(							UpperCAmelCase				):
					_snake_case       :					Tuple				       =   0
					_snake_case       :					Optional[Any]				       =   2

					while digits < n:
										index += 1
										_snake_case       :					str				       =   len(str(fibonacci(UpperCAmelCase				)				)				)

					return index







def    A				(							UpperCAmelCase = 1_000				):
					return fibonacci_digits_index(UpperCAmelCase				)


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