



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



	def 		UpperCamelCase							(						self							:    int)->							List[str]:
						__lowerCAmelCase	   ={
						    """task_specific_params""": {
						        """summarization""": {"""length_penalty""": 1.0, """max_length""": 1_28, """min_length""": 12, """num_beams""": 4},
						        """summarization_cnn""": {"""length_penalty""": 2.0, """max_length""": 1_42, """min_length""": 56, """num_beams""": 4},
						        """summarization_xsum""": {"""length_penalty""": 1.0, """max_length""": 62, """min_length""": 11, """num_beams""": 6},
						    }
						}
						__lowerCAmelCase	   ={
						    """task_specific_params.summarization.length_penalty""": 1.0,
						    """task_specific_params.summarization.max_length""": 1_28,
						    """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""": 1_42,
						    """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(snake_case_)				,	snake_case_)



	def 		UpperCamelCase							(						self							:    Tuple)->							Union[str, Any]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						self.assertTrue(np.allclose(transpose(snake_case_)				,	x.transpose()))

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



	@require_torch
	def 		UpperCamelCase							(						self							:    Union[str, Any])->							Optional[int]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =torch.tensor(snake_case_)
						self.assertTrue(np.allclose(transpose(snake_case_)				,	transpose(snake_case_).numpy()))

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



	@require_tf
	def 		UpperCamelCase							(						self							:    Union[str, Any])->							List[str]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =tf.constant(snake_case_)
						self.assertTrue(np.allclose(transpose(snake_case_)				,	transpose(snake_case_).numpy()))

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



	@require_flax
	def 		UpperCamelCase							(						self							:    Optional[int])->							Optional[int]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =jnp.array(snake_case_)
						self.assertTrue(np.allclose(transpose(snake_case_)				,	np.asarray(transpose(snake_case_))))

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



	def 		UpperCamelCase							(						self							:    Union[str, Any])->							Any:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						self.assertTrue(np.allclose(reshape(snake_case_				,	(4, 3))				,	np.reshape(snake_case_				,	(4, 3))))

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



	@require_torch
	def 		UpperCamelCase							(						self							:    List[Any])->							Any:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =torch.tensor(snake_case_)
						self.assertTrue(np.allclose(reshape(snake_case_				,	(4, 3))				,	reshape(snake_case_				,	(4, 3)).numpy()))

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



	@require_tf
	def 		UpperCamelCase							(						self							:    Optional[Any])->							Union[str, Any]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =tf.constant(snake_case_)
						self.assertTrue(np.allclose(reshape(snake_case_				,	(4, 3))				,	reshape(snake_case_				,	(4, 3)).numpy()))

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



	@require_flax
	def 		UpperCamelCase							(						self							:    Any)->							str:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =jnp.array(snake_case_)
						self.assertTrue(np.allclose(reshape(snake_case_				,	(4, 3))				,	np.asarray(reshape(snake_case_				,	(4, 3)))))

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



	def 		UpperCamelCase							(						self							:    Tuple)->							List[str]:
						__lowerCAmelCase	   =np.random.randn(1				,	3				,	4)
						self.assertTrue(np.allclose(squeeze(snake_case_)				,	np.squeeze(snake_case_)))

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



	@require_torch
	def 		UpperCamelCase							(						self							:    int)->							List[str]:
						__lowerCAmelCase	   =np.random.randn(1				,	3				,	4)
						__lowerCAmelCase	   =torch.tensor(snake_case_)
						self.assertTrue(np.allclose(squeeze(snake_case_)				,	squeeze(snake_case_).numpy()))

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



	@require_tf
	def 		UpperCamelCase							(						self							:    Optional[int])->							List[str]:
						__lowerCAmelCase	   =np.random.randn(1				,	3				,	4)
						__lowerCAmelCase	   =tf.constant(snake_case_)
						self.assertTrue(np.allclose(squeeze(snake_case_)				,	squeeze(snake_case_).numpy()))

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



	@require_flax
	def 		UpperCamelCase							(						self							:    Optional[int])->							Optional[int]:
						__lowerCAmelCase	   =np.random.randn(1				,	3				,	4)
						__lowerCAmelCase	   =jnp.array(snake_case_)
						self.assertTrue(np.allclose(squeeze(snake_case_)				,	np.asarray(squeeze(snake_case_))))

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



	def 		UpperCamelCase							(						self							:    List[Any])->							Any:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						self.assertTrue(np.allclose(expand_dims(snake_case_				,	axis=1)				,	np.expand_dims(snake_case_				,	axis=1)))



	@require_torch
	def 		UpperCamelCase							(						self							:    Optional[int])->							Optional[int]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =torch.tensor(snake_case_)
						self.assertTrue(np.allclose(expand_dims(snake_case_				,	axis=1)				,	expand_dims(snake_case_				,	axis=1).numpy()))



	@require_tf
	def 		UpperCamelCase							(						self							:    List[Any])->							List[Any]:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =tf.constant(snake_case_)
						self.assertTrue(np.allclose(expand_dims(snake_case_				,	axis=1)				,	expand_dims(snake_case_				,	axis=1).numpy()))



	@require_flax
	def 		UpperCamelCase							(						self							:    List[str])->							str:
						__lowerCAmelCase	   =np.random.randn(3				,	4)
						__lowerCAmelCase	   =jnp.array(snake_case_)
						self.assertTrue(np.allclose(expand_dims(snake_case_				,	axis=1)				,	np.asarray(expand_dims(snake_case_				,	axis=1))))









def 					__lowerCAmelCase		(  __lowerCamelCase	:    int = 3				,   __lowerCamelCase	:    int = 7				,   __lowerCamelCase	:    int = 1000000	)  ->						int:
					__lowerCAmelCase	   =0
					__lowerCAmelCase	   =1

					for current_denominator in range(1				,   limit + 1	):
										__lowerCAmelCase	   =current_denominator * numerator // denominator
										if current_denominator % denominator == 0:
															current_numerator -= 1
										if current_numerator * max_denominator > current_denominator * max_numerator:
															__lowerCAmelCase	   =current_numerator
															__lowerCAmelCase	   =current_denominator
					return max_numerator


if __name__ == "__main__":
				print(solution(numerator=3, denominator=7, limit=1_00_00_00))




