




import unittest
from timeit import timeit






def 					snake_case					(							A						,   A			)							->							int:




	'''simple docstring'''


	lowerCamelCase_							:		List[Any]							   =							first_num if first_num >= second_num else second_num
	lowerCamelCase_							:		int							   =							max_num
	while (common_mult % first_num > 0) or (common_mult % second_num > 0):
		common_mult += max_num
	return common_mult






def 					snake_case					(							A						,   A			)							->							int:




	'''simple docstring'''


	return b if a == 0 else greatest_common_divisor(b % a						,   A			)






def 					snake_case					(							A						,   A			)							->							int:




	'''simple docstring'''


	return first_num // greatest_common_divisor(A						,   A			) * second_num






def 					snake_case					(							)							->							List[Any]:




	'''simple docstring'''


	lowerCamelCase_							:		int							   =							(
	    'from __main__ import least_common_multiple_slow, least_common_multiple_fast'
	)
	print(
	    'least_common_multiple_slow():'						,   timeit('least_common_multiple_slow(1000, 999)'						,   setup=A			)						,   )
	print(
	    'least_common_multiple_fast():'						,   timeit('least_common_multiple_fast(1000, 999)'						,   setup=A			)						,   )


class 				__SCREAMING_SNAKE_CASE							(		unittest.TestCase  ):
					_lowerCamelCase		  = (
					    (10, 20),
					    (13, 15),
					    (4, 31),
					    (10, 42),
					    (43, 34),
					    (5, 12),
					    (12, 25),
					    (10, 25),
					    (6, 9),
					)
					_lowerCamelCase		  = (20, 1_95, 1_24, 2_10, 14_62, 60, 3_00, 50, 18)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						for i, (first_num, second_num) in enumerate(self.test_inputs					):
							lowerCamelCase_							:		Optional[int]							   =							least_common_multiple_slow(__lowercase ,       __lowercase					)
							lowerCamelCase_							:		Union[str, Any]							   =							least_common_multiple_fast(__lowercase ,       __lowercase					)
							with self.subTest(i=__lowercase					):
								self.assertEqual(__lowercase ,       self.expected_results[i]					)
								self.assertEqual(__lowercase ,       self.expected_results[i]					)


if __name__ == "__main__":
							benchmark()
							unittest.main()







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCAmelCase_        =			logging.get_logger(__name__)

lowerCAmelCase_        =			{
    """google/mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/config.json"""
}



class 				_lowerCAmelCase			(	UpperCAmelCase_							):


  '''simple docstring'''
  a_							:				List[Any]					    =MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP
  a_							:				Union[str, Any]					    ="""mobilebert"""







  def __init__(					self					:    int					, UpperCamelCase					:    int=3_05_22					, UpperCamelCase					:    Any=5_12					, UpperCamelCase					:    Any=24					, UpperCamelCase					:    List[str]=4					, UpperCamelCase					:    Any=5_12					, UpperCamelCase					:    str="relu"					, UpperCamelCase					:    Dict=0.0					, UpperCamelCase					:    int=0.1					, UpperCamelCase					:    Optional[Any]=5_12					, UpperCamelCase					:    str=2					, UpperCamelCase					:    Tuple=0.02					, UpperCamelCase					:    Union[str, Any]=1e-1_2					, UpperCamelCase					:    Optional[Any]=0					, UpperCamelCase					:    Union[str, Any]=1_28					, UpperCamelCase					:    Tuple=True					, UpperCamelCase					:    int=True					, UpperCamelCase					:    List[Any]=1_28					, UpperCamelCase					:    Dict=False					, UpperCamelCase					:    List[str]=True					, UpperCamelCase					:    Optional[Any]=4					, UpperCamelCase					:    int="no_norm"					, UpperCamelCase					:    Tuple=True					, UpperCamelCase					:    str=None					, **UpperCamelCase					:    str					, ):


    '''simple docstring'''





    super().__init__(pad_token_id=UpperCamelCase					, **UpperCamelCase							)

    _snake_case      : Union[str, Any]														=		vocab_size
    _snake_case      : Any														=		hidden_size
    _snake_case      : Tuple														=		num_hidden_layers
    _snake_case      : Any														=		num_attention_heads
    _snake_case      : Optional[Any]														=		hidden_act
    _snake_case      : List[Any]														=		intermediate_size
    _snake_case      : List[Any]														=		hidden_dropout_prob
    _snake_case      : Optional[int]														=		attention_probs_dropout_prob
    _snake_case      : int														=		max_position_embeddings
    _snake_case      : Optional[int]														=		type_vocab_size
    _snake_case      : Any														=		initializer_range
    _snake_case      : Optional[int]														=		layer_norm_eps
    _snake_case      : Tuple														=		embedding_size
    _snake_case      : int														=		trigram_input
    _snake_case      : Optional[int]														=		use_bottleneck
    _snake_case      : List[Any]														=		intra_bottleneck_size
    _snake_case      : Any														=		use_bottleneck_attention
    _snake_case      : str														=		key_query_shared_bottleneck
    _snake_case      : List[str]														=		num_feedforward_networks
    _snake_case      : int														=		normalization_type
    _snake_case      : str														=		classifier_activation

    if self.use_bottleneck:
      _snake_case      : Any														=		intra_bottleneck_size
    else:
      _snake_case      : Union[str, Any]														=		hidden_size

    _snake_case      : Dict														=		classifier_dropout




class 				_lowerCAmelCase			(	UpperCAmelCase_							):


  '''simple docstring'''







  @property
  def UpperCamelCase_       (					self					:    List[Any]							):


    '''simple docstring'''





    if self.task == "multiple-choice":
      _snake_case      : str														=		{0: 'batch', 1: 'choice', 2: 'sequence'}
    else:
      _snake_case      : Dict														=		{0: 'batch', 1: 'sequence'}
    return OrderedDict(
        [
            ('input_ids', dynamic_axis),
            ('attention_mask', dynamic_axis),
            ('token_type_ids', dynamic_axis),
        ]							)




