

import unittest

import numpy as np

from transformers import RoFormerConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
       import jax.numpy as jnp

       from transformers.models.roformer.modeling_flax_roformer import (
           FlaxRoFormerForMaskedLM,
           FlaxRoFormerForMultipleChoice,
           FlaxRoFormerForQuestionAnswering,
           FlaxRoFormerForSequenceClassification,
           FlaxRoFormerForTokenClassification,
           FlaxRoFormerModel,
       )







class 						__magic_name__			(							unittest.TestCase							):

   '''simple docstring'''




   def __init__(				self,    lowercase_,    lowercase_=13,    lowercase_=7,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=99,    lowercase_=32,    lowercase_=5,    lowercase_=4,    lowercase_=37,    lowercase_="gelu",    lowercase_=0.1,    lowercase_=0.1,    lowercase_=512,    lowercase_=16,    lowercase_=2,    lowercase_=0.02,    lowercase_=4,    )							->    Optional[int]:






     """simple docstring"""






     a__  =parent
     a__  =batch_size
     a__  =seq_length
     a__  =is_training
     a__  =use_attention_mask
     a__  =use_token_type_ids
     a__  =use_labels
     a__  =vocab_size
     a__  =hidden_size
     a__  =num_hidden_layers
     a__  =num_attention_heads
     a__  =intermediate_size
     a__  =hidden_act
     a__  =hidden_dropout_prob
     a__  =attention_probs_dropout_prob
     a__  =max_position_embeddings
     a__  =type_vocab_size
     a__  =type_sequence_label_size
     a__  =initializer_range
     a__  =num_choices



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =ids_tensor([self.batch_size, self.seq_length],    self.vocab_size       )

     a__  =None
     if self.use_attention_mask:
       a__  =random_attention_mask([self.batch_size, self.seq_length]       )

     a__  =None
     if self.use_token_type_ids:
       a__  =ids_tensor([self.batch_size, self.seq_length],    self.type_vocab_size       )

     a__  =RoFormerConfig(
         vocab_size=self.vocab_size,    hidden_size=self.hidden_size,    num_hidden_layers=self.num_hidden_layers,    num_attention_heads=self.num_attention_heads,    intermediate_size=self.intermediate_size,    hidden_act=self.hidden_act,    hidden_dropout_prob=self.hidden_dropout_prob,    attention_probs_dropout_prob=self.attention_probs_dropout_prob,    max_position_embeddings=self.max_position_embeddings,    type_vocab_size=self.type_vocab_size,    is_decoder=lowercase_,    initializer_range=self.initializer_range,    )

     return config, input_ids, token_type_ids, attention_mask



   def  _UpperCAmelCase (				self       )							->    List[Any]:






     """simple docstring"""






     a__  =self.prepare_config_and_inputs()
     a__,      a__,      a__,      a__  =config_and_inputs
     a__  ={'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
     return config, inputs_dict







@require_flax
class 						__magic_name__			(							lowerCamelCase__		,       unittest.TestCase							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[Any]    =   True

   lowerCamelCase__ :	str    =   (
       (
           FlaxRoFormerModel,
           FlaxRoFormerForMaskedLM,
           FlaxRoFormerForSequenceClassification,
           FlaxRoFormerForTokenClassification,
           FlaxRoFormerForMultipleChoice,
           FlaxRoFormerForQuestionAnswering,
       )
       if is_flax_available()
       else ()
   )



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     a__  =FlaxRoFormerModelTester(self       )



   @slow
   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     for model_class_name in self.all_model_classes:
       a__  =model_class_name.from_pretrained('''junnyu/roformer_chinese_small''',    from_pt=lowercase_       )
       a__  =model(np.ones((1, 1)       )       )
       self.assertIsNotNone(lowercase_       )







@require_flax
class 						__magic_name__			(							unittest.TestCase							):

   '''simple docstring'''




   @slow
   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =FlaxRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''       )
     a__  =jnp.array([[0, 1, 2, 3, 4, 5]]       )
     a__  =model(lowercase_       )[0]

     a__  =50000

     a__  =(1, 6, vocab_size)
     self.assertEqual(output.shape,    lowercase_       )

     a__  =jnp.array(
         [[[-0.1205, -1.0265, 0.2922], [-1.5134, 0.1974, 0.1519], [-5.0135, -3.9003, -0.8404]]]       )

     self.assertTrue(jnp.allclose(output[:, :3, :3],    lowercase_,    atol=1E-4       )       )



from math import factorial




def 			UpperCAmelCase__				(			_A      : int = 1_00							):





  '''simple docstring'''







  return sum(int(_A							) for x in str(factorial(_A							)							)							)


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