
from __future__ import annotations

from math import ceil, floor, sqrt



def 		UpperCamelCase     (       _UpperCAmelCase  :   int = 200_0000  )   ->			int:






						'''simple docstring'''

						_lowercase       :	list[int]           =   [0]
						_lowercase       :	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
						_lowercase       :	int           =   0
						# the area corresponding to the grid that gives the product closest to target
						_lowercase       :	int           =   0
						# an estimate of b, using the quadratic formula
						_lowercase       :	float
						# the largest integer less than b_estimate
						_lowercase       :	int
						# the largest integer less than b_estimate
						_lowercase       :	int
						# the triangle number corresponding to b_floor
						_lowercase       :	int
						# the triangle number corresponding to b_ceil
						_lowercase       :	int

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

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

												if abs(target - triangle_b_second_guess * triangle_a  ) < abs(
												    target - best_product  ):
																		_lowercase       :	Tuple           =   triangle_b_second_guess * triangle_a
																		_lowercase       :	Dict           =   idx_a * b_ceil

						return area


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






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCamelCase_						:     int	       =							{
    """configuration_transfo_xl""": ["""TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TransfoXLConfig"""],
    """tokenization_transfo_xl""": ["""TransfoXLCorpus""", """TransfoXLTokenizer"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_						:     Any	       =							[
							    """TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """AdaptiveEmbedding""",
							    """TransfoXLForSequenceClassification""",
							    """TransfoXLLMHeadModel""",
							    """TransfoXLModel""",
							    """TransfoXLPreTrainedModel""",
							    """load_tf_weights_in_transfo_xl""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCamelCase_						:     Tuple	       =							[
							    """TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TFAdaptiveEmbedding""",
							    """TFTransfoXLForSequenceClassification""",
							    """TFTransfoXLLMHeadModel""",
							    """TFTransfoXLMainLayer""",
							    """TFTransfoXLModel""",
							    """TFTransfoXLPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
							from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_transfo_xl import (
														    TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
														    AdaptiveEmbedding,
														    TransfoXLForSequenceClassification,
														    TransfoXLLMHeadModel,
														    TransfoXLModel,
														    TransfoXLPreTrainedModel,
														    load_tf_weights_in_transfo_xl,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_transfo_xl import (
														    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFAdaptiveEmbedding,
														    TFTransfoXLForSequenceClassification,
														    TFTransfoXLLMHeadModel,
														    TFTransfoXLMainLayer,
														    TFTransfoXLModel,
														    TFTransfoXLPreTrainedModel,
														)

else:
							import sys

							UpperCamelCase_						:     Optional[int]	       =							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




