


from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase__							:						int							     =   logging.get_logger(__name__)

lowerCamelCase__							:						List[Any]							     =   {
    """google/switch-base-8""": """https://huggingface.co/google/switch-base-8/blob/main/config.json""",
}
class 		__magic_name__						(snake_case_				):





     '''simple docstring'''



     __lowercase				:							Tuple	   =       'switch_transformers'
     __lowercase				:							Optional[int]	   =       ['past_key_values']
     __lowercase				:							Optional[int]	   =       {'hidden_size': 'd_model', 'num_attention_heads': 'num_heads', 'num_hidden_layers': 'num_layers'}

     def __init__(					self:Union[str, Any]     ,		_a:Tuple=3_21_28     ,		_a:Optional[Any]=7_68     ,		_a:Dict=64     ,		_a:Dict=20_48     ,		_a:Any=64     ,		_a:Optional[Any]=12     ,		_a:Tuple=3     ,		_a:List[Any]=12     ,		_a:Union[str, Any]=3     ,		_a:Optional[int]=12     ,		_a:Dict=8     ,		_a:Optional[Any]=False     ,		_a:Tuple=0.01     ,		_a:Tuple="float32"     ,		_a:Dict=False     ,		_a:List[str]=32     ,		_a:str=1_28     ,		_a:Tuple=0.1     ,		_a:List[str]=1e-6     ,		_a:List[Any]=0.001     ,		_a:Optional[Any]=0.001     ,		_a:List[Any]=1.0     ,		_a:Tuple="relu"     ,		_a:Any=True     ,		_a:Any=False     ,		_a:Dict=True     ,		_a:Any=0     ,		_a:int=1     ,		**_a:Optional[Any]     ,		):
       snake_case__						= vocab_size
       snake_case__						= d_model
       snake_case__						= d_kv
       snake_case__						= d_ff

       snake_case__						= num_sparse_encoder_layers

       snake_case__						= num_layers
       snake_case__						= (
           num_decoder_layers if num_decoder_layers is not None else self.num_layers
       )  # default = symmetry
       snake_case__						= num_sparse_decoder_layers

       # This tells us, each how many encoder layer we'll have to set a sparse layer.
       if self.num_sparse_encoder_layers > 0:
         snake_case__						= self.num_layers // self.num_sparse_encoder_layers
       else:
         snake_case__						= self.num_layers  # HACK: this will create 0 sparse layers

       # This tells us, each how many encoder layer we'll have to set a sparse layer.
       if self.num_sparse_decoder_layers > 0:
         snake_case__						= self.num_decoder_layers // self.num_sparse_decoder_layers
       else:
         snake_case__						= self.num_decoder_layers  # HACK: this will create 0 sparse layers

       snake_case__						= num_heads
       snake_case__						= num_experts
       snake_case__						= expert_capacity
       snake_case__						= router_bias
       snake_case__						= router_jitter_noise
       if router_dtype not in ["float32", "float16", "bfloat16"]:
         raise ValueError(F"""`router_dtype` must be one of 'float32', 'float16' or 'bfloat16', got {router_dtype}"""   )
       snake_case__						= router_dtype

       snake_case__						= router_ignore_padding_tokens
       snake_case__						= relative_attention_num_buckets
       snake_case__						= relative_attention_max_distance

       snake_case__						= dropout_rate
       snake_case__						= layer_norm_epsilon
       snake_case__						= initializer_factor
       snake_case__						= feed_forward_proj
       snake_case__						= use_cache
       snake_case__						= add_router_probs

       snake_case__						= router_z_loss_coef
       snake_case__						= router_aux_loss_coef

       snake_case__						= self.feed_forward_proj.split('''-'''   )
       snake_case__						= act_info[-1]
       snake_case__						= act_info[0] == '''gated'''

       if len(_a   ) > 1 and act_info[0] != "gated" or len(_a   ) > 2:
         raise ValueError(
             F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."""
             '''Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '''
             '''\'gated-gelu\' or \'relu\''''   )

       # for backwards compatibility
       if feed_forward_proj == "gated-gelu":
         snake_case__						= '''gelu_new'''

       super().__init__(
           pad_token_id=_a     ,		eos_token_id=_a     ,		is_encoder_decoder=_a     ,		**_a     ,		)





def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase = 100				)    ->				int:
  snake_case__						= set()

  snake_case__						= 0

  snake_case__						= n + 1  # maximum limit

  for a in range(2							,   __lowerCAmelCase				):
    for b in range(2							,   __lowerCAmelCase				):
      snake_case__						= a**b  # calculates the current power
      collect_powers.add(__lowerCAmelCase				)  # adds the result to the set
  return len(__lowerCAmelCase				)


if __name__ == "__main__":
   print("""Number of terms """, solution(int(str(input()).strip())))

