
import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
    import tensorflow as tf

    from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

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

__lowerCAmelCase			:     int           =   logging.get_logger(__name__)




class        UpperCAmelCase_			( enum.Enum     ):


  '''simple docstring'''







  a__           =		0
  a__           =		1







@add_end_docstrings(a__     )
class        UpperCAmelCase_			( a__     ):


  '''simple docstring'''







  a__           =		"""generated"""
  def __init__( self			: Tuple			,							*UpperCamelCase__			: List[str]			,							**UpperCamelCase__			: Tuple    )			->	Any:







    """simple docstring"""






    super().__init__(*__lowerCAmelCase			,							**__lowerCAmelCase    )

    self.check_model_type(
        TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
        if self.framework == """tf"""
        else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING    )
  def 							_lowercase							( self			: Any			,							UpperCamelCase__			: List[str]=None			,							UpperCamelCase__			: int=None			,							UpperCamelCase__			: Any=None			,							UpperCamelCase__			: Optional[Any]=None			,							UpperCamelCase__			: Tuple=None			,							UpperCamelCase__			: List[str]=None			,							**UpperCamelCase__			: str			,							)			->	List[str]:







    """simple docstring"""






    __magic_name__				     =       {}
    if truncation is not None:
      __magic_name__				     =       truncation

    __magic_name__				     =       generate_kwargs

    __magic_name__				     =       {}
    if return_tensors is not None and return_type is None:
      __magic_name__				     =       ReturnType.TENSORS if return_tensors else ReturnType.TEXT
    if return_type is not None:
      __magic_name__				     =       return_type

    if clean_up_tokenization_spaces is not None:
      __magic_name__				     =       clean_up_tokenization_spaces

    if stop_sequence is not None:
      __magic_name__				     =       self.tokenizer.encode(__lowerCAmelCase			,							add_special_tokens=__lowerCAmelCase    )
      if len(__lowerCAmelCase    ) > 1:
        warnings.warn(
            """Stopping on a multiple token sequence is not yet supported on transformers. The first token of"""
            """ the stop sequence will be used as the stop sequence string in the interim."""    )
      __magic_name__				     =       stop_sequence_ids[0]

    return preprocess_params, forward_params, postprocess_params
  def 							_lowercase							( self			: Tuple			,							UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: Optional[Any]    )			->	Tuple:







    """simple docstring"""






    return True
  def 							_lowercase							( self			: Any			,							*UpperCamelCase__			: List[str]			,							UpperCamelCase__			: List[Any]    )			->	str:







    """simple docstring"""






    __magic_name__				     =       self.model.config.prefix if self.model.config.prefix is not None else ''''''
    if isinstance(args[0]			,							__lowerCAmelCase    ):
      if self.tokenizer.pad_token_id is None:
        raise ValueError("""Please make sure that the tokenizer has a pad_token_id when using a batch input"""    )
      __magic_name__				     =       ([prefix + arg for arg in args[0]],)
      __magic_name__				     =       True

    elif isinstance(args[0]			,							__lowerCAmelCase    ):
      __magic_name__				     =       (prefix + args[0],)
      __magic_name__				     =       False
    else:
      raise ValueError(
          F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''    )
    __magic_name__				     =       self.tokenizer(*__lowerCAmelCase			,							padding=__lowerCAmelCase			,							truncation=__lowerCAmelCase			,							return_tensors=self.framework    )
    # This is produced by tokenizers but is an invalid generate kwargs
    if "token_type_ids" in inputs:
      del inputs["token_type_ids"]
    return inputs
  def __call__( self			: Tuple			,							*UpperCamelCase__			: List[str]			,							**UpperCamelCase__			: List[Any]    )			->	List[str]:







    """simple docstring"""






    __magic_name__				     =       super().__call__(*__lowerCAmelCase			,							**__lowerCAmelCase    )
    if (
        isinstance(args[0]			,							__lowerCAmelCase    )
        and all(isinstance(__lowerCAmelCase			,							__lowerCAmelCase    ) for el in args[0]    )
        and all(len(__lowerCAmelCase    ) == 1 for res in result    )
    ):
      return [res[0] for res in result]
    return result
  def 							_lowercase							( self			: List[str]			,							UpperCamelCase__			: int			,							UpperCamelCase__			: Any=TruncationStrategy.DO_NOT_TRUNCATE			,							**UpperCamelCase__			: Tuple    )			->	Tuple:







    """simple docstring"""






    __magic_name__				     =       self._parse_and_tokenize(__lowerCAmelCase			,							truncation=__lowerCAmelCase			,							**__lowerCAmelCase    )
    return inputs
  def 							_lowercase							( self			: List[Any]			,							UpperCamelCase__			: Tuple			,							**UpperCamelCase__			: Optional[int]    )			->	Dict:







    """simple docstring"""






    if self.framework == "pt":
      __magic_name__				     =       model_inputs['''input_ids'''].shape
    elif self.framework == "tf":
      __magic_name__				     =       tf.shape(model_inputs["""input_ids"""]    ).numpy()

    __magic_name__				     =       generate_kwargs.get("""min_length"""			,							self.model.config.min_length    )
    __magic_name__				     =       generate_kwargs.get("""max_length"""			,							self.model.config.max_length    )
    self.check_inputs(__lowerCAmelCase			,							generate_kwargs["""min_length"""]			,							generate_kwargs["""max_length"""]    )
    __magic_name__				     =       self.model.generate(**__lowerCAmelCase			,							**__lowerCAmelCase    )
    __magic_name__				     =       output_ids.shape[0]
    if self.framework == "pt":
      __magic_name__				     =       output_ids.reshape(__lowerCAmelCase			,							out_b // in_b			,							*output_ids.shape[1:]    )
    elif self.framework == "tf":
      __magic_name__				     =       tf.reshape(__lowerCAmelCase			,							(in_b, out_b // in_b, *output_ids.shape[1:])    )
    return {"output_ids": output_ids}





  def 							_lowercase							( self			: Any			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: Tuple=ReturnType.TEXT			,							UpperCamelCase__			: int=False    )			->	Any:







    """simple docstring"""






    __magic_name__				     =       []
    for output_ids in model_outputs["output_ids"][0]:
      if return_type == ReturnType.TENSORS:
        __magic_name__				     =       {F'''{self.return_name}_token_ids''': output_ids}
      elif return_type == ReturnType.TEXT:
        __magic_name__				     =       {
            F'''{self.return_name}_text''': self.tokenizer.decode(
                __lowerCAmelCase			,							skip_special_tokens=__lowerCAmelCase			,							clean_up_tokenization_spaces=__lowerCAmelCase			,							)
        }
      records.append(__lowerCAmelCase    )
    return records







@add_end_docstrings(a__     )
class        UpperCAmelCase_			( a__     ):


  '''simple docstring'''







  a__           =		"""summary"""
  def __call__( self			: Dict			,							*UpperCamelCase__			: Tuple			,							**UpperCamelCase__			: Optional[Any]    )			->	str:







    """simple docstring"""






    return super().__call__(*__lowerCAmelCase			,							**__lowerCAmelCase    )





  def 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: Dict			,							UpperCamelCase__			: List[Any]			,							UpperCamelCase__			: Tuple    )			->	bool:







    """simple docstring"""






    if max_length < min_length:
      logger.warning(F'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''    )

    if input_length < max_length:
      logger.warning(
          F'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
          """a summarization task, where outputs shorter than the input are typically wanted, you might """
          F'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''    )







@add_end_docstrings(a__     )
class        UpperCAmelCase_			( a__     ):


  '''simple docstring'''







  a__           =		"""translation"""
  def 							_lowercase							( self			: Tuple			,							UpperCamelCase__			: str			,							UpperCamelCase__			: Tuple			,							UpperCamelCase__			: Optional[int]    )			->	Tuple:







    """simple docstring"""






    if input_length > 0.9 * max_length:
      logger.warning(
          F'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
          """increasing your max_length manually, e.g. translator(\'...\', max_length=400)"""    )
    return True
  def 							_lowercase							( self			: List[str]			,							*UpperCamelCase__			: Dict			,							UpperCamelCase__			: List[str]=TruncationStrategy.DO_NOT_TRUNCATE			,							UpperCamelCase__			: str=None			,							UpperCamelCase__			: Tuple=None    )			->	Dict:







    """simple docstring"""






    if getattr(self.tokenizer			,							"""_build_translation_inputs"""			,							__lowerCAmelCase    ):
      return self.tokenizer._build_translation_inputs(
          *__lowerCAmelCase			,							return_tensors=self.framework			,							truncation=__lowerCAmelCase			,							src_lang=__lowerCAmelCase			,							tgt_lang=__lowerCAmelCase    )
    else:
      return super()._parse_and_tokenize(*__lowerCAmelCase			,							truncation=__lowerCAmelCase    )
  def 							_lowercase							( self			: Optional[Any]			,							UpperCamelCase__			: Optional[int]=None			,							UpperCamelCase__			: List[str]=None			,							**UpperCamelCase__			: Optional[Any]    )			->	Union[str, Any]:







    """simple docstring"""






    __magic_name__				     =       super()._sanitize_parameters(**__lowerCAmelCase    )
    if src_lang is not None:
      __magic_name__				     =       src_lang
    if tgt_lang is not None:
      __magic_name__				     =       tgt_lang
    if src_lang is None and tgt_lang is None:
      # Backward compatibility, direct arguments use is preferred.
      __magic_name__				     =       kwargs.get("""task"""			,							self.task    )
      __magic_name__				     =       task.split("""_"""    )
      if task and len(__lowerCAmelCase    ) == 4:
        # translation, XX, to YY
        __magic_name__				     =       items[1]
        __magic_name__				     =       items[3]
    return preprocess_params, forward_params, postprocess_params





  def __call__( self			: Optional[int]			,							*UpperCamelCase__			: Optional[int]			,							**UpperCamelCase__			: Union[str, Any]    )			->	List[str]:







    """simple docstring"""






    return super().__call__(*__lowerCAmelCase			,							**__lowerCAmelCase    )


'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[int]  =					1
 for i in range(1		,     num + 1     ):
  fact *= i
 return fact
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 lowercase__				:    Optional[Any]  =					0
 while number > 0:
  lowercase__				:    str  =					number % 10
  sum_of_digits += last_digit
  lowercase__				:    List[str]  =					number // 10  # Removing the last_digit from the given number
 return sum_of_digits
def 			__UpperCamelCase       (   UpperCAmelCase = 100     ):
 lowercase__				:    Optional[int]  =					factorial(UpperCAmelCase     )
 lowercase__				:    Dict  =					split_and_add(UpperCAmelCase     )
 return result


if __name__ == "__main__":
  print(solution(int(input("""Enter the Number: """).strip())))

