





"""simple docstring"""




from __future__ import annotations

from math import ceil, floor, sqrt






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					int = 200_0000      )				->int:






	'''simple docstring'''






	a   :	list[int]			=       [0]
	a   :	int

	for idx in range(1					, ceil(sqrt(target * 2      ) * 1.1      )      ):
		triangle_numbers.append(triangle_numbers[-1] + idx      )

	# we want this to be as close as possible to target
	a   :	int			=       0
	# the area corresponding to the grid that gives the product closest to target
	a   :	int			=       0
	# an estimate of b, using the quadratic formula
	a   :	float
	# the largest integer less than b_estimate
	a   :	int
	# the largest integer less than b_estimate
	a   :	int
	# the triangle number corresponding to b_floor
	a   :	int
	# the triangle number corresponding to b_ceil
	a   :	int

	for idx_a, triangle_a in enumerate(triangle_numbers[1:]					, 1      ):
		a   :	List[Any]			=       (-1 + sqrt(1 + 8 * target / triangle_a      )) / 2
		a   :	Any			=       floor(_lowercase      )
		a   :	Optional[Any]			=       ceil(_lowercase      )
		a   :	Union[str, Any]			=       triangle_numbers[b_floor]
		a   :	Optional[int]			=       triangle_numbers[b_ceil]

		if abs(target - triangle_b_first_guess * triangle_a      ) < abs(
		    target - best_product      ):
			a   :	List[str]			=       triangle_b_first_guess * triangle_a
			a   :	Any			=       idx_a * b_floor

		if abs(target - triangle_b_second_guess * triangle_a      ) < abs(
		    target - best_product      ):
			a   :	Any			=       triangle_b_second_guess * triangle_a
			a   :	int			=       idx_a * b_ceil

	return area


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









"""simple docstring"""




import unittest

from diffusers.pipelines.pipeline_utils import is_safetensors_compatible


class  __UpperCamelCase       (		unittest.TestCase		):






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	Optional[int]			=       [
								    "safety_checker/pytorch_model.bin",
								    "safety_checker/model.safetensors",
								    "vae/diffusion_pytorch_model.bin",
								    "vae/diffusion_pytorch_model.safetensors",
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	str			=       [
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Dict:
								a   :	List[str]			=       [
								    "safety_checker/pytorch_model.bin",
								    "safety_checker/model.safetensors",
								    "vae/diffusion_pytorch_model.bin",
								    "vae/diffusion_pytorch_model.safetensors",
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								    "unet/diffusion_pytorch_model.bin",
								    # Removed: 'unet/diffusion_pytorch_model.safetensors',
								]
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				List[Any]:
								a   :	Optional[Any]			=       [
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								]
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Tuple:
								a   :	Tuple			=       [
								    "safety_checker/pytorch_model.bin",
								    "safety_checker/model.safetensors",
								    "vae/diffusion_pytorch_model.bin",
								    "vae/diffusion_pytorch_model.safetensors",
								    "text_encoder/pytorch_model.bin",
								    # Removed: 'text_encoder/model.safetensors',
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Dict:
								a   :	Dict			=       [
								    "safety_checker/pytorch_model.fp16.bin",
								    "safety_checker/model.fp16.safetensors",
								    "vae/diffusion_pytorch_model.fp16.bin",
								    "vae/diffusion_pytorch_model.fp16.safetensors",
								    "text_encoder/pytorch_model.fp16.bin",
								    "text_encoder/model.fp16.safetensors",
								    "unet/diffusion_pytorch_model.fp16.bin",
								    "unet/diffusion_pytorch_model.fp16.safetensors",
								]
								a   :	Dict			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				List[str]:
								a   :	List[Any]			=       [
								    "unet/diffusion_pytorch_model.fp16.bin",
								    "unet/diffusion_pytorch_model.fp16.safetensors",
								]
								a   :	Any			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				int:
								# pass variant but use the non-variant filenames
								a   :	int			=       [
								    "unet/diffusion_pytorch_model.bin",
								    "unet/diffusion_pytorch_model.safetensors",
								]
								a   :	Tuple			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				str:
								a   :	str			=       [
								    "safety_checker/pytorch_model.fp16.bin",
								    "safety_checker/model.fp16.safetensors",
								    "vae/diffusion_pytorch_model.fp16.bin",
								    "vae/diffusion_pytorch_model.fp16.safetensors",
								    "text_encoder/pytorch_model.fp16.bin",
								    "text_encoder/model.fp16.safetensors",
								    "unet/diffusion_pytorch_model.fp16.bin",
								    # Removed: 'unet/diffusion_pytorch_model.fp16.safetensors',
								]
								a   :	Any			=       "fp16"
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				str:
								a   :	Union[str, Any]			=       [
								    "text_encoder/pytorch_model.fp16.bin",
								    "text_encoder/model.fp16.safetensors",
								]
								a   :	str			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				List[str]:
								# pass variant but use the non-variant filenames
								a   :	Optional[int]			=       [
								    "text_encoder/pytorch_model.bin",
								    "text_encoder/model.safetensors",
								]
								a   :	str			=       "fp16"
								self.assertTrue(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )






							def 					__a     (     self   )			->				Optional[Any]:
								a   :	Any			=       [
								    "safety_checker/pytorch_model.fp16.bin",
								    "safety_checker/model.fp16.safetensors",
								    "vae/diffusion_pytorch_model.fp16.bin",
								    "vae/diffusion_pytorch_model.fp16.safetensors",
								    "text_encoder/pytorch_model.fp16.bin",
								    # 'text_encoder/model.fp16.safetensors',
								    "unet/diffusion_pytorch_model.fp16.bin",
								    "unet/diffusion_pytorch_model.fp16.safetensors",
								]
								a   :	Optional[int]			=       "fp16"
								self.assertFalse(is_safetensors_compatible(lowerCAmelCase__   ,      variant=lowerCAmelCase__   )   )


