



import numpy as np

import datasets


__UpperCAmelCase			  =			'''\nCompute the Mahalanobis Distance\n\nMahalonobis distance is the distance between a point and a distribution.\nAnd not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.\nIt was introduced by Prof. P. C. Mahalanobis in 1936\nand has been used in various statistical applications ever since\n[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]\n'''

__UpperCAmelCase			  =			'''\\n@article{de2000mahalanobis,\n  title={The mahalanobis distance},\n  author={De Maesschalck, Roy and Jouan-Rimbaud, Delphine and Massart, D{\'e}sir{\'e} L},\n  journal={Chemometrics and intelligent laboratory systems},\n  volume={50},\n  number={1},\n  pages={1--18},\n  year={2000},\n  publisher={Elsevier}\n}\n'''

__UpperCAmelCase			  =			'''\nArgs:\n    X: List of datapoints to be compared with the `reference_distribution`.\n    reference_distribution: List of datapoints from the reference distribution we want to compare to.\nReturns:\n    mahalanobis: The Mahalonobis distance for each datapoint in `X`.\nExamples:\n\n    >>> mahalanobis_metric = datasets.load_metric(\"mahalanobis\")\n    >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])\n    >>> print(results)\n    {\'mahalanobis\': array([0.5])}\n'''



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION			,       _KWARGS_DESCRIPTION				)
class 							lowerCAmelCase_						(    datasets.Metric				):
       def    snake_case_			(     self			)	->						Optional[int]:
          return datasets.MetricInfo(
              description=_DESCRIPTION,     citation=_CITATION,     inputs_description=_KWARGS_DESCRIPTION,     features=datasets.Features(
                  {
                      'X': datasets.Sequence(datasets.Value('float',     id='sequence'			),     id='X'			),
                  }			),     )






       def    snake_case_			(     self,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			)	->						int:
          # convert to numpy arrays
          UpperCamelCase       :    Any		      =      np.array(__lowerCamelCase			)
          UpperCamelCase       :    Tuple		      =      np.array(__lowerCamelCase			)

          # Assert that arrays are 2D
          if len(X.shape			) != 2:
             raise ValueError('Expected `X` to be a 2D vector'			)
          if len(reference_distribution.shape			) != 2:
             raise ValueError('Expected `reference_distribution` to be a 2D vector'			)
          if reference_distribution.shape[0] < 2:
             raise ValueError(
                 'Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension'			)

          # Get mahalanobis distance for each prediction
          UpperCamelCase       :    List[Any]		      =      X - np.mean(__lowerCamelCase			)
          UpperCamelCase       :    Union[str, Any]		      =      np.cov(reference_distribution.T			)
          try:
             UpperCamelCase       :    Dict		      =      np.linalg.inv(__lowerCamelCase			)
          except np.linalg.LinAlgError:
             UpperCamelCase       :    List[Any]		      =      np.linalg.pinv(__lowerCamelCase			)
          UpperCamelCase       :    Dict		      =      np.dot(__lowerCamelCase,     __lowerCamelCase			)
          UpperCamelCase       :    Dict		      =      np.dot(__lowerCamelCase,     X_minus_mu.T			).diagonal()

          return {"mahalanobis": mahal_dist}









'''simple docstring'''






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   int:
      if n == 1 or not isinstance(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		):
            return 0
      elif n == 2:
            return 1
      else:
            snake_case__       :   int	      =    [0, 1]
            for i in range(2				,      n + 1		):
                  sequence.append(sequence[i - 1] + sequence[i - 2]		)

            return sequence[n]






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   int:
      snake_case__       :   Optional[int]	      =    0
      snake_case__       :   Dict	      =    2

      while digits < n:
            index += 1
            snake_case__       :   Optional[int]	      =    len(str(fibonacci(__SCREAMING_SNAKE_CASE		)		)		)

      return index






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE = 1000		)    ->   int:
      return fibonacci_digits_index(__SCREAMING_SNAKE_CASE		)


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