
import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin




class        UpperCAmelCase_			( a__     ):


  '''simple docstring'''







  a__           =		None
  a__           =		None
  @property
  def 							_lowercase							( self			: Any    )			->	Any:







    """simple docstring"""






    return self.feat_extract_tester.prepare_feat_extract_dict()
  def 							_lowercase							( self			: List[Any]    )			->	List[str]:







    """simple docstring"""






    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    self.assertTrue(hasattr(__lowerCAmelCase			,							"""feature_size"""    )    )
    self.assertTrue(hasattr(__lowerCAmelCase			,							"""sampling_rate"""    )    )
    self.assertTrue(hasattr(__lowerCAmelCase			,							"""padding_value"""    )    )
  def 							_lowercase							( self			: Optional[Any]    )			->	Optional[Any]:







    """simple docstring"""






    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common()
    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )

    self.assertTrue(all(len(__lowerCAmelCase    ) == len(__lowerCAmelCase    ) for x, y in zip(__lowerCAmelCase			,							processed_features[input_name]    )    )    )

    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCAmelCase    )
    __magic_name__				     =       BatchFeature({input_name: speech_inputs}			,							tensor_type="""np"""    )

    __magic_name__				     =       processed_features[input_name]

    if len(batch_features_input.shape    ) < 3:
      __magic_name__				     =       batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.feature_size)    )
  @require_torch
  def 							_lowercase							( self			: Optional[int]    )			->	str:







    """simple docstring"""






    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCAmelCase    )
    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}			,							tensor_type="""pt"""    )

    __magic_name__				     =       processed_features[input_name]

    if len(batch_features_input.shape    ) < 3:
      __magic_name__				     =       batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.feature_size)    )
  @require_tf
  def 							_lowercase							( self			: int    )			->	str:







    """simple docstring"""






    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=__lowerCAmelCase    )
    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}			,							tensor_type="""tf"""    )

    __magic_name__				     =       processed_features[input_name]

    if len(batch_features_input.shape    ) < 3:
      __magic_name__				     =       batch_features_input[:, :, None]

    self.assertTrue(
        batch_features_input.shape
        == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.feature_size)    )
  def 							_lowercase							( self			: Optional[int]			,							UpperCamelCase__			: Any=False    )			->	List[Any]:







    """simple docstring"""






    def _inputs_have_equal_length(UpperCamelCase__			: Any    ):
      __magic_name__				     =       len(input[0]    )
      for input_slice in input[1:]:
        if len(__lowerCAmelCase    ) != length:
          return False
      return True

    def _inputs_are_equal(UpperCamelCase__			: int			,							UpperCamelCase__			: List[str]    ):
      if len(__lowerCAmelCase    ) != len(__lowerCAmelCase    ):
        return False

      for input_slice_a, input_slice_a in zip(__lowerCAmelCase			,							__lowerCAmelCase    ):
        if not np.allclose(np.asarray(__lowerCAmelCase    )			,							np.asarray(__lowerCAmelCase    )			,							atol=1E-3    ):
          return False
      return True

    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common(numpify=__lowerCAmelCase    )
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )

    __magic_name__				     =       self.feat_extract_tester.seq_length_diff
    __magic_name__				     =       self.feat_extract_tester.max_seq_length + pad_diff
    __magic_name__				     =       self.feat_extract_tester.min_seq_length
    __magic_name__				     =       self.feat_extract_tester.batch_size
    __magic_name__				     =       self.feat_extract_tester.feature_size

    # test padding for List[int] + numpy
    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding=__lowerCAmelCase    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[-1]    )    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							return_tensors="""np"""    )
    __magic_name__				     =       input_a[input_name]

    # max_length parameter has to be provided when setting `padding="max_length"`
    with self.assertRaises(__lowerCAmelCase    ):
      feat_extract.pad(__lowerCAmelCase			,							padding="""max_length"""    )[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=__lowerCAmelCase			,							return_tensors="""np"""    )
    __magic_name__				     =       input_a[input_name]

    self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(_inputs_are_equal(__lowerCAmelCase			,							__lowerCAmelCase    )    )
    self.assertTrue(len(input_a[0]    ) == pad_min_length    )
    self.assertTrue(len(input_a[1]    ) == pad_min_length + pad_diff    )
    self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]    ))    )
    self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)    )

    if feature_size > 1:
      self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size    )

    # test padding for `pad_to_multiple_of` for List[int] + numpy
    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							pad_to_multiple_of=10    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							pad_to_multiple_of=10    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							pad_to_multiple_of=10			,							max_length=__lowerCAmelCase    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							pad_to_multiple_of=10			,							max_length=__lowerCAmelCase			,							return_tensors="""np"""			,							)
    __magic_name__				     =       input_a[input_name]

    self.assertTrue(all(len(__lowerCAmelCase    ) % 10 == 0 for x in input_a    )    )
    self.assertTrue(_inputs_are_equal(__lowerCAmelCase			,							__lowerCAmelCase    )    )

    __magic_name__				     =       pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
    self.assertTrue(all(len(__lowerCAmelCase    ) == expected_mult_pad_length for x in input_a    )    )
    self.assertEqual(input_a.shape[:2]			,							(batch_size, expected_mult_pad_length)    )

    if feature_size > 1:
      self.assertTrue(input_a.shape[2] == feature_size    )

    # Check padding value is correct
    __magic_name__				     =       (np.ones(self.feat_extract_tester.feature_size    ) * feat_extract.padding_value).sum()
    self.assertTrue(
        abs(np.asarray(input_a[0]    )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)    )
        < 1E-3    )
    self.assertTrue(
        abs(
            np.asarray(input_a[1]    )[pad_min_length + pad_diff :].sum()
            - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)    )
        < 1E-3    )
    self.assertTrue(
        abs(
            np.asarray(input_a[2]    )[pad_min_length + 2 * pad_diff :].sum()
            - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)    )
        < 1E-3    )
    self.assertTrue(
        abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)    ) < 1E-3    )
    self.assertTrue(
        abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)    )
        < 1E-3    )
  def 							_lowercase							( self			: List[Any]			,							UpperCamelCase__			: Dict=False    )			->	Union[str, Any]:







    """simple docstring"""






    def _inputs_have_equal_length(UpperCamelCase__			: Optional[int]    ):
      __magic_name__				     =       len(input[0]    )
      for input_slice in input[1:]:
        if len(__lowerCAmelCase    ) != length:
          return False
      return True

    def _inputs_are_equal(UpperCamelCase__			: Optional[Any]			,							UpperCamelCase__			: Tuple    ):
      if len(__lowerCAmelCase    ) != len(__lowerCAmelCase    ):
        return False

      for input_slice_a, input_slice_a in zip(__lowerCAmelCase			,							__lowerCAmelCase    ):
        if not np.allclose(np.asarray(__lowerCAmelCase    )			,							np.asarray(__lowerCAmelCase    )			,							atol=1E-3    ):
          return False
      return True

    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common(numpify=__lowerCAmelCase    )
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )

    # truncate to smallest
    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[0]    )			,							truncation=__lowerCAmelCase    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[0]    )    )
    __magic_name__				     =       input_a[input_name]

    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase    )    )

    # truncate to smallest with np
    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[0]    )			,							return_tensors="""np"""			,							truncation=__lowerCAmelCase			,							)
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[0]    )			,							return_tensors="""np"""    )
    __magic_name__				     =       input_a[input_name]

    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(input_a.shape[1] == len(speech_inputs[0]    )    )

    # since truncation forces padding to be smaller than longest input
    # function can't return `np.ndarray`, but has to return list
    self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase    )    )

    # truncate to middle
    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[1]    )			,							truncation=__lowerCAmelCase			,							return_tensors="""np"""			,							)
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[1]    )			,							truncation=__lowerCAmelCase    )
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[1]    )			,							return_tensors="""np"""    )
    __magic_name__				     =       input_a[input_name]

    self.assertTrue(input_a.shape[1] == len(speech_inputs[1]    )    )
    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(_inputs_are_equal(__lowerCAmelCase			,							__lowerCAmelCase    )    )

    # since truncation forces padding to be smaller than longest input
    # function can't return `np.ndarray`, but has to return list
    self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertTrue(len(input_a[-1]    ) == len(speech_inputs[-1]    )    )

    # padding has to be max_length when setting `truncation=True`
    with self.assertRaises(__lowerCAmelCase    ):
      feat_extract.pad(__lowerCAmelCase			,							truncation=__lowerCAmelCase    )[input_name]

    # padding has to be max_length when setting `truncation=True`
    with self.assertRaises(__lowerCAmelCase    ):
      feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							truncation=__lowerCAmelCase    )[input_name]

    # padding has to be max_length when setting `truncation=True`
    with self.assertRaises(__lowerCAmelCase    ):
      feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							truncation=__lowerCAmelCase    )[input_name]

    # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
    with self.assertRaises(__lowerCAmelCase    ):
      feat_extract.pad(__lowerCAmelCase			,							padding="""max_length"""			,							truncation=__lowerCAmelCase    )[input_name]

    # test truncation for `pad_to_multiple_of` for List[int] + numpy
    __magic_name__				     =       12
    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[0]    )			,							pad_to_multiple_of=__lowerCAmelCase			,							truncation=__lowerCAmelCase			,							)
    __magic_name__				     =       input_a[input_name]

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=len(speech_inputs[0]    )			,							pad_to_multiple_of=__lowerCAmelCase			,							)
    __magic_name__				     =       input_a[input_name]

    # retrieve expected_length as multiple of pad_to_multiple_of
    __magic_name__				     =       len(speech_inputs[0]    )
    if expected_length % pad_to_multiple_of != 0:
      __magic_name__				     =       ((len(speech_inputs[0]    ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

    self.assertTrue(len(input_a[0]    ) == expected_length    )
    self.assertTrue(_inputs_have_equal_length(__lowerCAmelCase    )    )
    self.assertFalse(_inputs_have_equal_length(__lowerCAmelCase    )    )
  def 							_lowercase							( self			: Union[str, Any]    )			->	List[str]:







    """simple docstring"""






    self._check_padding(numpify=__lowerCAmelCase    )
  def 							_lowercase							( self			: Any    )			->	int:







    """simple docstring"""






    self._check_padding(numpify=__lowerCAmelCase    )
  def 							_lowercase							( self			: Any    )			->	str:







    """simple docstring"""






    self._check_truncation(numpify=__lowerCAmelCase    )
  def 							_lowercase							( self			: Union[str, Any]    )			->	Optional[int]:







    """simple docstring"""






    self._check_truncation(numpify=__lowerCAmelCase    )
  @require_torch
  def 							_lowercase							( self			: Optional[int]    )			->	List[Any]:







    """simple docstring"""






    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common()
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							return_tensors="""np"""    )[input_name]
    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							return_tensors="""pt"""    )[input_name]

    self.assertTrue(abs(input_np.astype(np.floataa    ).sum() - input_pt.numpy().astype(np.floataa    ).sum()    ) < 1E-2    )
  @require_tf
  def 							_lowercase							( self			: Optional[Any]    )			->	int:







    """simple docstring"""






    __magic_name__				     =       self.feature_extraction_class(**self.feat_extract_dict    )
    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common()
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							return_tensors="""np"""    )[input_name]
    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							return_tensors="""tf"""    )[input_name]

    self.assertTrue(abs(input_np.astype(np.floataa    ).sum() - input_tf.numpy().astype(np.floataa    ).sum()    ) < 1E-2    )
  def 							_lowercase							( self			: int    )			->	int:







    """simple docstring"""






    __magic_name__				     =       self.feat_extract_dict
    __magic_name__				     =       True
    __magic_name__				     =       self.feature_extraction_class(**__lowerCAmelCase    )
    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common()
    __magic_name__				     =       [len(__lowerCAmelCase    ) for x in speech_inputs]
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )

    __magic_name__				     =       feat_extract.pad(__lowerCAmelCase			,							padding="""longest"""			,							return_tensors="""np"""    )
    self.assertIn("""attention_mask"""			,							__lowerCAmelCase    )
    self.assertListEqual(list(processed.attention_mask.shape    )			,							list(processed[input_name].shape[:2]    )    )
    self.assertListEqual(processed.attention_mask.sum(-1    ).tolist()			,							__lowerCAmelCase    )





  def 							_lowercase							( self			: List[str]    )			->	List[Any]:







    """simple docstring"""






    __magic_name__				     =       self.feat_extract_dict
    __magic_name__				     =       True
    __magic_name__				     =       self.feature_extraction_class(**__lowerCAmelCase    )
    __magic_name__				     =       self.feat_extract_tester.prepare_inputs_for_common()
    __magic_name__				     =       [len(__lowerCAmelCase    ) for x in speech_inputs]
    __magic_name__				     =       feat_extract.model_input_names[0]

    __magic_name__				     =       BatchFeature({input_name: speech_inputs}    )
    __magic_name__				     =       min(__lowerCAmelCase    )

    __magic_name__				     =       feat_extract.pad(
        __lowerCAmelCase			,							padding="""max_length"""			,							max_length=__lowerCAmelCase			,							truncation=__lowerCAmelCase			,							return_tensors="""np"""    )
    self.assertIn("""attention_mask"""			,							__lowerCAmelCase    )
    self.assertListEqual(
        list(processed_pad.attention_mask.shape    )			,							[processed_pad[input_name].shape[0], max_length]    )
    self.assertListEqual(
        processed_pad.attention_mask[:, :max_length].sum(-1    ).tolist()			,							[max_length for x in speech_inputs]    )


'''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())))

