



'''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 				snake_case (unittest.TestCase   ):



       def 							_a      (				self      )  ->							str:
           lowercase__		       =						{
               "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},
               }
           }
           lowercase__		       =						{
               "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(UpperCAmelCase_      )     ,UpperCAmelCase_      )



       def 							_a      (				self      )  ->							int:
           lowercase__		       =						np.random.randn(3     ,4      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_      )     ,x.transpose()      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      )     ,x.transpose((1, 2, 0)      )      )      )



       @require_torch
       def 							_a      (				self      )  ->							Optional[Any]:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_      )     ,transpose(UpperCAmelCase_      ).numpy()      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      )     ,transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      ).numpy()      )      )



       @require_tf
       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_      )     ,transpose(UpperCAmelCase_      ).numpy()      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      )     ,transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      ).numpy()      )      )



       @require_flax
       def 							_a      (				self      )  ->							Any:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_      )     ,np.asarray(transpose(UpperCAmelCase_      )      )      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      )     ,np.asarray(transpose(UpperCAmelCase_     ,axes=(1, 2, 0)      )      )      )      )



       def 							_a      (				self      )  ->							Optional[int]:
           lowercase__		       =						np.random.randn(3     ,4      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(4, 3)      )     ,np.reshape(UpperCAmelCase_     ,(4, 3)      )      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(12, 5)      )     ,np.reshape(UpperCAmelCase_     ,(12, 5)      )      )      )



       @require_torch
       def 							_a      (				self      )  ->							int:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(4, 3)      )     ,reshape(UpperCAmelCase_     ,(4, 3)      ).numpy()      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(12, 5)      )     ,reshape(UpperCAmelCase_     ,(12, 5)      ).numpy()      )      )



       @require_tf
       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(4, 3)      )     ,reshape(UpperCAmelCase_     ,(4, 3)      ).numpy()      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(12, 5)      )     ,reshape(UpperCAmelCase_     ,(12, 5)      ).numpy()      )      )



       @require_flax
       def 							_a      (				self      )  ->							Union[str, Any]:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(4, 3)      )     ,np.asarray(reshape(UpperCAmelCase_     ,(4, 3)      )      )      )      )

           lowercase__		       =						np.random.randn(3     ,4     ,5      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(reshape(UpperCAmelCase_     ,(12, 5)      )     ,np.asarray(reshape(UpperCAmelCase_     ,(12, 5)      )      )      )      )



       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						np.random.randn(1     ,3     ,4      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_      )     ,np.squeeze(UpperCAmelCase_      )      )      )

           lowercase__		       =						np.random.randn(1     ,4     ,1     ,5      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_     ,axis=2      )     ,np.squeeze(UpperCAmelCase_     ,axis=2      )      )      )



       @require_torch
       def 							_a      (				self      )  ->							int:
           lowercase__		       =						np.random.randn(1     ,3     ,4      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_      )     ,squeeze(UpperCAmelCase_      ).numpy()      )      )

           lowercase__		       =						np.random.randn(1     ,4     ,1     ,5      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_     ,axis=2      )     ,squeeze(UpperCAmelCase_     ,axis=2      ).numpy()      )      )



       @require_tf
       def 							_a      (				self      )  ->							List[str]:
           lowercase__		       =						np.random.randn(1     ,3     ,4      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_      )     ,squeeze(UpperCAmelCase_      ).numpy()      )      )

           lowercase__		       =						np.random.randn(1     ,4     ,1     ,5      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_     ,axis=2      )     ,squeeze(UpperCAmelCase_     ,axis=2      ).numpy()      )      )



       @require_flax
       def 							_a      (				self      )  ->							Any:
           lowercase__		       =						np.random.randn(1     ,3     ,4      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_      )     ,np.asarray(squeeze(UpperCAmelCase_      )      )      )      )

           lowercase__		       =						np.random.randn(1     ,4     ,1     ,5      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(squeeze(UpperCAmelCase_     ,axis=2      )     ,np.asarray(squeeze(UpperCAmelCase_     ,axis=2      )      )      )      )



       def 							_a      (				self      )  ->							int:
           lowercase__		       =						np.random.randn(3     ,4      )
           self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_     ,axis=1      )     ,np.expand_dims(UpperCAmelCase_     ,axis=1      )      )      )



       @require_torch
       def 							_a      (				self      )  ->							Dict:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						torch.tensor(UpperCAmelCase_      )
           self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_     ,axis=1      )     ,expand_dims(UpperCAmelCase_     ,axis=1      ).numpy()      )      )



       @require_tf
       def 							_a      (				self      )  ->							Any:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						tf.constant(UpperCAmelCase_      )
           self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_     ,axis=1      )     ,expand_dims(UpperCAmelCase_     ,axis=1      ).numpy()      )      )







       @require_flax
       def 							_a      (				self      )  ->							Dict:
           lowercase__		       =						np.random.randn(3     ,4      )
           lowercase__		       =						jnp.array(UpperCAmelCase_      )
           self.assertTrue(np.allclose(expand_dims(UpperCAmelCase_     ,axis=1      )     ,np.asarray(expand_dims(UpperCAmelCase_     ,axis=1      )      )      )      )









'''simple docstring'''





def        lowerCamelCase  (				_snake_case  :						int = 4_000_000       ):





    '''simple docstring'''


    lowercase__		       =						[0, 1]
    lowercase__		       =						0
    while fib[i] <= n:
        fib.append(fib[i] + fib[i + 1]       )
        if fib[i + 2] > n:
            break
        i += 1
    lowercase__		       =						0
    for j in range(len(_snake_case       ) - 1       ):
        if fib[j] % 2 == 0:
            total += fib[j]

    return total


if __name__ == "__main__":
 print(f'''{solution() = }''')




