
def 						_snake_case(  ) ->    Optional[Any]:
       for n in range(1					,	1_000_000				):
              yield n * (n + 1) // 2







def 						_snake_case(  SCREAMING_SNAKE_CASE__				) ->    Dict:
       lowercase							:     Tuple       	=      1
       lowercase							:     int       	=      2
       while i * i <= n:
              lowercase							:     Union[str, Any]       	=      0
              while n % i == 0:
                     n //= i
                     multiplicity += 1
              divisors_count *= multiplicity + 1
              i += 1
       if n > 1:
              divisors_count *= 2
       return divisors_count







def 						_snake_case(  ) ->    List[Any]:
       return next(i for i in triangle_number_generator() if count_divisors(SCREAMING_SNAKE_CASE__				) > 500				)


if __name__ == "__main__":
  print(solution())


from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
  from PIL import Image

  from ..image_utils import load_image

if is_tf_available():
  import tensorflow as tf

  from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  from ..tf_utils import stable_softmax

if is_torch_available():
  from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

lowercase  :					Any						    =							logging.get_logger(__name__)

@add_end_docstrings(lowerCAmelCase     )
class __snake_case		(      lowerCAmelCase     ):
    def __init__(  self		,*snake_case		,**snake_case      ):



           '''simple docstring'''







           super().__init__(*snake_case		,**snake_case      )
           requires_backends(self		,"""vision"""      )
           self.check_model_type(
               TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
               if self.framework == """tf"""
               else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING      )
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case=None      ):



           '''simple docstring'''







           lowercase							:     List[Any]       	=      {}
           if top_k is not None:
                  lowercase							:     int       	=      top_k
           return {}, {}, postprocess_params
    def __call__(  self		,snake_case		,**snake_case      ):



           '''simple docstring'''







           return super().__call__(snake_case		,**snake_case      )
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           lowercase							:     Any       	=      load_image(snake_case      )
           lowercase							:     List[Any]       	=      self.image_processor(images=snake_case		,return_tensors=self.framework      )
           return model_inputs
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case      ):



           '''simple docstring'''







           lowercase							:     int       	=      self.model(**snake_case      )
           return model_outputs
    def       _SCREAMING_SNAKE_CASE       (  self		,snake_case		,snake_case=5      ):



           '''simple docstring'''







           if top_k > self.model.config.num_labels:
                  lowercase							:     Tuple       	=      self.model.config.num_labels

           if self.framework == "pt":
                  lowercase							:     str       	=      model_outputs.logits.softmax(-1      )[0]
                  lowercase	,			lowercase							:     Dict       	=      probs.topk(snake_case      )
           elif self.framework == "tf":
                  lowercase							:     Optional[int]       	=      stable_softmax(model_outputs.logits		,axis=-1      )[0]
                  lowercase							:     Union[str, Any]       	=      tf.math.top_k(snake_case		,k=snake_case      )
                  lowercase	,			lowercase							:     List[str]       	=      topk.values.numpy(), topk.indices.numpy()
           else:
                  raise ValueError(f"Unsupported framework: {self.framework}"      )

           lowercase							:     Tuple       	=      scores.tolist()
           lowercase							:     Dict       	=      ids.tolist()
           return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(snake_case		,snake_case      )]
