code: 
  
  
  '''simple docstring'''
  
  import unittest
  
  import numpy as np
  
  from transformers import ElectraConfig, 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():
         from transformers.models.electra.modeling_flax_electra import (
             FlaxElectraForCausalLM,
             FlaxElectraForMaskedLM,
             FlaxElectraForMultipleChoice,
             FlaxElectraForPreTraining,
             FlaxElectraForQuestionAnswering,
             FlaxElectraForSequenceClassification,
             FlaxElectraForTokenClassification,
             FlaxElectraModel,
         )
  
  
  
  
  
  
  
  class  UpperCAmelCase (       unittest.TestCase):
  
   def __init__( self :	Dict,					a_ :	List[str],					a_ :	str=13,					a_ :	int=7,					a_ :	Tuple=True,					a_ :	Optional[int]=True,					a_ :	Optional[int]=True,					a_ :	Optional[Any]=True,					a_ :	List[str]=99,					a_ :	Tuple=24,					a_ :	int=32,					a_ :	Union[str, Any]=5,					a_ :	int=4,					a_ :	Any=37,					a_ :	Any="gelu",					a_ :	Any=0.1,					a_ :	int=0.1,					a_ :	List[str]=512,					a_ :	Optional[int]=16,					a_ :	List[str]=2,					a_ :	List[str]=0.02,					a_ :	str=4,					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						parent
      UpperCamelCase__ 						=						batch_size
      UpperCamelCase__ 						=						seq_length
      UpperCamelCase__ 						=						is_training
      UpperCamelCase__ 						=						use_attention_mask
      UpperCamelCase__ 						=						use_token_type_ids
      UpperCamelCase__ 						=						use_labels
      UpperCamelCase__ 						=						vocab_size
      UpperCamelCase__ 						=						hidden_size
      UpperCamelCase__ 						=						embedding_size
      UpperCamelCase__ 						=						num_hidden_layers
      UpperCamelCase__ 						=						num_attention_heads
      UpperCamelCase__ 						=						intermediate_size
      UpperCamelCase__ 						=						hidden_act
      UpperCamelCase__ 						=						hidden_dropout_prob
      UpperCamelCase__ 						=						attention_probs_dropout_prob
      UpperCamelCase__ 						=						max_position_embeddings
      UpperCamelCase__ 						=						type_vocab_size
      UpperCamelCase__ 						=						type_sequence_label_size
      UpperCamelCase__ 						=						initializer_range
      UpperCamelCase__ 						=						num_choices
  
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						ids_tensor([self.batch_size, self.seq_length],					self.vocab_size					)
  
      UpperCamelCase__ 						=						None
      if self.use_attention_mask:
         UpperCamelCase__ 						=						random_attention_mask([self.batch_size, self.seq_length]					)
  
      UpperCamelCase__ 						=						None
      if self.use_token_type_ids:
         UpperCamelCase__ 						=						ids_tensor([self.batch_size, self.seq_length],					self.type_vocab_size					)
  
      UpperCamelCase__ 						=						ElectraConfig(
          vocab_size=self.vocab_size,					hidden_size=self.hidden_size,					embedding_size=self.embedding_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,					initializer_range=self.initializer_range,					)
  
      return config, input_ids, token_type_ids, attention_mask
  
   def 		lowercase_						( self :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						self.prepare_config_and_inputs()
      UpperCamelCase__						,		UpperCamelCase__						,		UpperCamelCase__						,		UpperCamelCase__ 						=						config_and_inputs
      UpperCamelCase__ 						=						{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": attention_mask}
      return config, inputs_dict
  
  
  
  
  
  
  
  @require_flax
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__		,			unittest.TestCase):
   _lowerCamelCase :					Optional[int]    					=					True
  
   _lowerCamelCase :					int    					=					(
       (
           FlaxElectraModel,
           FlaxElectraForCausalLM,
           FlaxElectraForMaskedLM,
           FlaxElectraForPreTraining,
           FlaxElectraForTokenClassification,
           FlaxElectraForQuestionAnswering,
           FlaxElectraForMultipleChoice,
           FlaxElectraForSequenceClassification,
       )
       if is_flax_available()
       else ()
   )
  
   def 		lowercase_						( self :	Union[str, Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						FlaxElectraModelTester(self					)
  
   @slow
   def 		lowercase_						( self :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      for model_class_name in self.all_model_classes:
         if model_class_name == FlaxElectraForMaskedLM:
            UpperCamelCase__ 						=						model_class_name.from_pretrained("google/electra-small-generator"					)
         else:
            UpperCamelCase__ 						=						model_class_name.from_pretrained("google/electra-small-discriminator"					)
         UpperCamelCase__ 						=						model(np.ones((1, 1)					)					)
         self.assertIsNotNone(a_					)
style_context: 
  
  
  '''simple docstring'''
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int = 10_00   )		->					int:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     return sum(i for i in range(_UpperCamelCase   ) if i % 3 == 0 or i % 5 == 0   )
  
  
  if __name__ == "__main__":
         print(F"""{solution() = }""")