
"""simple docstring"""
import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
      import jax.numpy as jnp

if is_tf_available():
      import tensorflow as tf

if is_torch_available():
      import torch
class       UpperCamelCase   (				unittest.TestCase	):
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			{
           "task_specific_params": {
               "summarization": {"length_penalty": 1.0, "max_length": 128, "min_length": 12, "num_beams": 4},
               "summarization_cnn": {"length_penalty": 2.0, "max_length": 142, "min_length": 56, "num_beams": 4},
               "summarization_xsum": {"length_penalty": 1.0, "max_length": 62, "min_length": 11, "num_beams": 6},
           }
       }
       _SCREAMING_SNAKE_CASE :					Optional[int]				     =			{
           "task_specific_params.summarization.length_penalty": 1.0,
           "task_specific_params.summarization.max_length": 128,
           "task_specific_params.summarization.min_length": 12,
           "task_specific_params.summarization.num_beams": 4,
           "task_specific_params.summarization_cnn.length_penalty": 2.0,
           "task_specific_params.summarization_cnn.max_length": 142,
           "task_specific_params.summarization_cnn.min_length": 56,
           "task_specific_params.summarization_cnn.num_beams": 4,
           "task_specific_params.summarization_xsum.length_penalty": 1.0,
           "task_specific_params.summarization_xsum.max_length": 62,
           "task_specific_params.summarization_xsum.min_length": 11,
           "task_specific_params.summarization_xsum.num_beams": 6,
       }

       self.assertEqual(flatten_dict(_a					)	,  _a					)
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			np.random.randn(3	,  4					)
       self.assertTrue(np.allclose(transpose(_a					)	,  x.transpose()					)					)

       _SCREAMING_SNAKE_CASE :					Tuple				     =			np.random.randn(3	,  4	,  5					)
       self.assertTrue(np.allclose(transpose(_a	,  axes=(1, 2, 0)					)	,  x.transpose((1, 2, 0)					)					)					)
     @require_torch
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Any				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					Any				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(transpose(_a					)	,  transpose(_a					).numpy()					)					)

       _SCREAMING_SNAKE_CASE :					Any				     =			np.random.randn(3	,  4	,  5					)
       _SCREAMING_SNAKE_CASE :					List[Any]				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(transpose(_a	,  axes=(1, 2, 0)					)	,  transpose(_a	,  axes=(1, 2, 0)					).numpy()					)					)
     @require_tf
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					int				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					Optional[int]				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(transpose(_a					)	,  transpose(_a					).numpy()					)					)

       _SCREAMING_SNAKE_CASE :					List[Any]				     =			np.random.randn(3	,  4	,  5					)
       _SCREAMING_SNAKE_CASE :					Tuple				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(transpose(_a	,  axes=(1, 2, 0)					)	,  transpose(_a	,  axes=(1, 2, 0)					).numpy()					)					)
     @require_flax
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					List[str]				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					str				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(transpose(_a					)	,  np.asarray(transpose(_a					)					)					)					)

       _SCREAMING_SNAKE_CASE :					Optional[int]				     =			np.random.randn(3	,  4	,  5					)
       _SCREAMING_SNAKE_CASE :					List[str]				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(transpose(_a	,  axes=(1, 2, 0)					)	,  np.asarray(transpose(_a	,  axes=(1, 2, 0)					)					)					)					)
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			np.random.randn(3	,  4					)
       self.assertTrue(np.allclose(reshape(_a	,  (4, 3)					)	,  np.reshape(_a	,  (4, 3)					)					)					)

       _SCREAMING_SNAKE_CASE :					List[str]				     =			np.random.randn(3	,  4	,  5					)
       self.assertTrue(np.allclose(reshape(_a	,  (12, 5)					)	,  np.reshape(_a	,  (12, 5)					)					)					)
     @require_torch
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					List[str]				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					Any				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(reshape(_a	,  (4, 3)					)	,  reshape(_a	,  (4, 3)					).numpy()					)					)

       _SCREAMING_SNAKE_CASE :					Optional[int]				     =			np.random.randn(3	,  4	,  5					)
       _SCREAMING_SNAKE_CASE :					List[str]				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(reshape(_a	,  (12, 5)					)	,  reshape(_a	,  (12, 5)					).numpy()					)					)
     @require_tf
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					str				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(reshape(_a	,  (4, 3)					)	,  reshape(_a	,  (4, 3)					).numpy()					)					)

       _SCREAMING_SNAKE_CASE :					Any				     =			np.random.randn(3	,  4	,  5					)
       _SCREAMING_SNAKE_CASE :					int				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(reshape(_a	,  (12, 5)					)	,  reshape(_a	,  (12, 5)					).numpy()					)					)
     @require_flax
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Optional[int]				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					int				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(reshape(_a	,  (4, 3)					)	,  np.asarray(reshape(_a	,  (4, 3)					)					)					)					)

       _SCREAMING_SNAKE_CASE :					List[str]				     =			np.random.randn(3	,  4	,  5					)
       _SCREAMING_SNAKE_CASE :					int				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(reshape(_a	,  (12, 5)					)	,  np.asarray(reshape(_a	,  (12, 5)					)					)					)					)
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					str				     =			np.random.randn(1	,  3	,  4					)
       self.assertTrue(np.allclose(squeeze(_a					)	,  np.squeeze(_a					)					)					)

       _SCREAMING_SNAKE_CASE :					Any				     =			np.random.randn(1	,  4	,  1	,  5					)
       self.assertTrue(np.allclose(squeeze(_a	,  axis=2					)	,  np.squeeze(_a	,  axis=2					)					)					)
     @require_torch
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			np.random.randn(1	,  3	,  4					)
       _SCREAMING_SNAKE_CASE :					str				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(squeeze(_a					)	,  squeeze(_a					).numpy()					)					)

       _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			np.random.randn(1	,  4	,  1	,  5					)
       _SCREAMING_SNAKE_CASE :					List[Any]				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(squeeze(_a	,  axis=2					)	,  squeeze(_a	,  axis=2					).numpy()					)					)
     @require_tf
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					List[Any]				     =			np.random.randn(1	,  3	,  4					)
       _SCREAMING_SNAKE_CASE :					Any				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(squeeze(_a					)	,  squeeze(_a					).numpy()					)					)

       _SCREAMING_SNAKE_CASE :					List[Any]				     =			np.random.randn(1	,  4	,  1	,  5					)
       _SCREAMING_SNAKE_CASE :					Tuple				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(squeeze(_a	,  axis=2					)	,  squeeze(_a	,  axis=2					).numpy()					)					)
     @require_flax
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Union[str, Any]				     =			np.random.randn(1	,  3	,  4					)
       _SCREAMING_SNAKE_CASE :					List[Any]				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(squeeze(_a					)	,  np.asarray(squeeze(_a					)					)					)					)

       _SCREAMING_SNAKE_CASE :					str				     =			np.random.randn(1	,  4	,  1	,  5					)
       _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(squeeze(_a	,  axis=2					)	,  np.asarray(squeeze(_a	,  axis=2					)					)					)					)
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Optional[Any]				     =			np.random.randn(3	,  4					)
       self.assertTrue(np.allclose(expand_dims(_a	,  axis=1					)	,  np.expand_dims(_a	,  axis=1					)					)					)
     @require_torch
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Any				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					List[str]				     =			torch.tensor(_a					)
       self.assertTrue(np.allclose(expand_dims(_a	,  axis=1					)	,  expand_dims(_a	,  axis=1					).numpy()					)					)
     @require_tf
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					Any				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					List[Any]				     =			tf.constant(_a					)
       self.assertTrue(np.allclose(expand_dims(_a	,  axis=1					)	,  expand_dims(_a	,  axis=1					).numpy()					)					)




     @require_flax
     def 					__SCREAMING_SNAKE_CASE				(  self					):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE :					List[Any]				     =			np.random.randn(3	,  4					)
       _SCREAMING_SNAKE_CASE :					Tuple				     =			jnp.array(_a					)
       self.assertTrue(np.allclose(expand_dims(_a	,  axis=1					)	,  np.asarray(expand_dims(_a	,  axis=1					)					)					)					)









"""simple docstring"""




def        a__					(							snake_case__ = 10_00							)		->   int:
			lowerCamelCase ,  lowerCamelCase      =   1, 1
			lowerCamelCase      =   2
			while True:
						lowerCamelCase      =   0
						lowerCamelCase      =   fa + fa
						lowerCamelCase ,  lowerCamelCase      =   fa, f
						index += 1
						for _ in str(snake_case__							):
									i += 1
						if i == n:
									break
			return index


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



