



'''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 	lowerCAmelCase_(    unittest.TestCase					):
		'''simple docstring'''




		def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
						lowerCAmelCase__			:  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},
						    }
						}
						lowerCAmelCase__			:  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(__UpperCAmelCase				)  ,__UpperCAmelCase				)




		def 							UpperCAmelCase_     (   self				)   ->		Optional[Any]:
						lowerCAmelCase__			:  Union[str, Any]											= np.random.randn(3  ,4				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase				)  ,x.transpose()				)				)

						lowerCAmelCase__			:  List[str]											= np.random.randn(3  ,4  ,5				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				)  ,x.transpose((1, 2, 0)				)				)				)




		@require_torch
		def 							UpperCAmelCase_     (   self				)   ->		Tuple:
						lowerCAmelCase__			:  List[Any]											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  Union[str, Any]											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase				)  ,transpose(__UpperCAmelCase				).numpy()				)				)

						lowerCAmelCase__			:  Tuple											= np.random.randn(3  ,4  ,5				)
						lowerCAmelCase__			:  str											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				)  ,transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				).numpy()				)				)




		@require_tf
		def 							UpperCAmelCase_     (   self				)   ->		Optional[Any]:
						lowerCAmelCase__			:  Union[str, Any]											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  int											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase				)  ,transpose(__UpperCAmelCase				).numpy()				)				)

						lowerCAmelCase__			:  List[str]											= np.random.randn(3  ,4  ,5				)
						lowerCAmelCase__			:  Optional[Any]											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				)  ,transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				).numpy()				)				)




		@require_flax
		def 							UpperCAmelCase_     (   self				)   ->		int:
						lowerCAmelCase__			:  Union[str, Any]											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  Dict											= jnp.array(__UpperCAmelCase				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase				)  ,np.asarray(transpose(__UpperCAmelCase				)				)				)				)

						lowerCAmelCase__			:  str											= np.random.randn(3  ,4  ,5				)
						lowerCAmelCase__			:  Optional[Any]											= jnp.array(__UpperCAmelCase				)
						self.assertTrue(np.allclose(transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				)  ,np.asarray(transpose(__UpperCAmelCase  ,axes=(1, 2, 0)				)				)				)				)




		def 							UpperCAmelCase_     (   self				)   ->		Union[str, Any]:
						lowerCAmelCase__			:  Dict											= np.random.randn(3  ,4				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(4, 3)				)  ,np.reshape(__UpperCAmelCase  ,(4, 3)				)				)				)

						lowerCAmelCase__			:  int											= np.random.randn(3  ,4  ,5				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(12, 5)				)  ,np.reshape(__UpperCAmelCase  ,(12, 5)				)				)				)




		@require_torch
		def 							UpperCAmelCase_     (   self				)   ->		Optional[int]:
						lowerCAmelCase__			:  Union[str, Any]											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  str											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(4, 3)				)  ,reshape(__UpperCAmelCase  ,(4, 3)				).numpy()				)				)

						lowerCAmelCase__			:  Any											= np.random.randn(3  ,4  ,5				)
						lowerCAmelCase__			:  int											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(12, 5)				)  ,reshape(__UpperCAmelCase  ,(12, 5)				).numpy()				)				)




		@require_tf
		def 							UpperCAmelCase_     (   self				)   ->		Optional[Any]:
						lowerCAmelCase__			:  Optional[int]											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  Any											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(4, 3)				)  ,reshape(__UpperCAmelCase  ,(4, 3)				).numpy()				)				)

						lowerCAmelCase__			:  Optional[int]											= np.random.randn(3  ,4  ,5				)
						lowerCAmelCase__			:  Union[str, Any]											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(12, 5)				)  ,reshape(__UpperCAmelCase  ,(12, 5)				).numpy()				)				)




		@require_flax
		def 							UpperCAmelCase_     (   self				)   ->		Tuple:
						lowerCAmelCase__			:  Any											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  Dict											= jnp.array(__UpperCAmelCase				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(4, 3)				)  ,np.asarray(reshape(__UpperCAmelCase  ,(4, 3)				)				)				)				)

						lowerCAmelCase__			:  Dict											= np.random.randn(3  ,4  ,5				)
						lowerCAmelCase__			:  Dict											= jnp.array(__UpperCAmelCase				)
						self.assertTrue(np.allclose(reshape(__UpperCAmelCase  ,(12, 5)				)  ,np.asarray(reshape(__UpperCAmelCase  ,(12, 5)				)				)				)				)




		def 							UpperCAmelCase_     (   self				)   ->		str:
						lowerCAmelCase__			:  Dict											= np.random.randn(1  ,3  ,4				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase				)  ,np.squeeze(__UpperCAmelCase				)				)				)

						lowerCAmelCase__			:  List[Any]											= np.random.randn(1  ,4  ,1  ,5				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase  ,axis=2				)  ,np.squeeze(__UpperCAmelCase  ,axis=2				)				)				)




		@require_torch
		def 							UpperCAmelCase_     (   self				)   ->		List[Any]:
						lowerCAmelCase__			:  List[str]											= np.random.randn(1  ,3  ,4				)
						lowerCAmelCase__			:  Tuple											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase				)  ,squeeze(__UpperCAmelCase				).numpy()				)				)

						lowerCAmelCase__			:  List[str]											= np.random.randn(1  ,4  ,1  ,5				)
						lowerCAmelCase__			:  Dict											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase  ,axis=2				)  ,squeeze(__UpperCAmelCase  ,axis=2				).numpy()				)				)




		@require_tf
		def 							UpperCAmelCase_     (   self				)   ->		Any:
						lowerCAmelCase__			:  Union[str, Any]											= np.random.randn(1  ,3  ,4				)
						lowerCAmelCase__			:  Tuple											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase				)  ,squeeze(__UpperCAmelCase				).numpy()				)				)

						lowerCAmelCase__			:  List[Any]											= np.random.randn(1  ,4  ,1  ,5				)
						lowerCAmelCase__			:  Optional[int]											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase  ,axis=2				)  ,squeeze(__UpperCAmelCase  ,axis=2				).numpy()				)				)




		@require_flax
		def 							UpperCAmelCase_     (   self				)   ->		Dict:
						lowerCAmelCase__			:  Dict											= np.random.randn(1  ,3  ,4				)
						lowerCAmelCase__			:  int											= jnp.array(__UpperCAmelCase				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase				)  ,np.asarray(squeeze(__UpperCAmelCase				)				)				)				)

						lowerCAmelCase__			:  Dict											= np.random.randn(1  ,4  ,1  ,5				)
						lowerCAmelCase__			:  str											= jnp.array(__UpperCAmelCase				)
						self.assertTrue(np.allclose(squeeze(__UpperCAmelCase  ,axis=2				)  ,np.asarray(squeeze(__UpperCAmelCase  ,axis=2				)				)				)				)




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




		@require_torch
		def 							UpperCAmelCase_     (   self				)   ->		Optional[int]:
						lowerCAmelCase__			:  List[Any]											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  str											= torch.tensor(__UpperCAmelCase				)
						self.assertTrue(np.allclose(expand_dims(__UpperCAmelCase  ,axis=1				)  ,expand_dims(__UpperCAmelCase  ,axis=1				).numpy()				)				)




		@require_tf
		def 							UpperCAmelCase_     (   self				)   ->		Dict:
						lowerCAmelCase__			:  Any											= np.random.randn(3  ,4				)
						lowerCAmelCase__			:  Union[str, Any]											= tf.constant(__UpperCAmelCase				)
						self.assertTrue(np.allclose(expand_dims(__UpperCAmelCase  ,axis=1				)  ,expand_dims(__UpperCAmelCase  ,axis=1				).numpy()				)				)






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







'''simple docstring'''





def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase = 1000      ):



    """simple docstring"""





    lowerCAmelCase__			:  Union[str, Any]											= -1
    lowerCAmelCase__			:  Optional[Any]											= 0
    for a in range(1							,   n // 3      ):
        # Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c
        lowerCAmelCase__			:  Optional[Any]											= (n * n - 2 * a * n) // (2 * n - 2 * a)
        lowerCAmelCase__			:  Tuple											= n - a - b
        if c * c == (a * a + b * b):
            lowerCAmelCase__			:  int											= a * b * c
            if candidate >= product:
                lowerCAmelCase__			:  Any											= candidate
    return product


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


