'''simple docstring'''




from transformers import SqueezeBertTokenizer, SqueezeBertTokenizerFast
from transformers.testing_utils import require_tokenizers, slow

from ..bert.test_tokenization_bert import BertTokenizationTest

@require_tokenizers
class      lowerCamelCase_     (snake_case__   ):
						'''simple docstring'''

						__UpperCamelCase:  List[str]      =						SqueezeBertTokenizer
						__UpperCamelCase:  List[Any]      =						SqueezeBertTokenizerFast
						__UpperCamelCase:  int      =						True




						def 					_A     (	self						:    Optional[int]						, **A						:    str	):
													return SqueezeBertTokenizerFast.from_pretrained(self.tmpdirname						, **A	)





						@slow
						def 					_A     (	self						:    List[Any]	):
													_UpperCAmelCase					:  List[Any]											=   SqueezeBertTokenizer.from_pretrained("squeezebert/squeezebert-mnli-headless"	)

													_UpperCAmelCase					:  Optional[Any]											=   tokenizer.encode("sequence builders"						, add_special_tokens=A	)
													_UpperCAmelCase					:  int											=   tokenizer.encode("multi-sequence build"						, add_special_tokens=A	)

													_UpperCAmelCase					:  Union[str, Any]											=   tokenizer.build_inputs_with_special_tokens(A	)
													_UpperCAmelCase					:  List[Any]											=   tokenizer.build_inputs_with_special_tokens(A						, A	)

													assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
													assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
													    tokenizer.sep_token_id
													]


'''simple docstring'''




def      UpperCamelCase_							( _UpperCAmelCase  :				Optional[int]      ,     _UpperCAmelCase  :				List[Any]   )   ->   List[str]:


       """simple docstring"""







       if len(str(_UpperCAmelCase   )   ) == 1 or len(str(_UpperCAmelCase   )   ) == 1:
              return a * b

       _UpperCAmelCase					:  Any											=   max(len(str(_UpperCAmelCase   )   )      ,     len(str(_UpperCAmelCase   )   )   )
       _UpperCAmelCase					:  Any											=   ma // 2

       _UpperCAmelCase				,  _UpperCAmelCase					:  Union[str, Any]											=   divmod(_UpperCAmelCase      ,     10**ma   )
       _UpperCAmelCase				,  _UpperCAmelCase					:  int											=   divmod(_UpperCAmelCase      ,     10**ma   )

       _UpperCAmelCase					:  List[str]											=   karatsuba(_UpperCAmelCase      ,     _UpperCAmelCase   )
       _UpperCAmelCase					:  int											=   karatsuba((aa + aa)      ,     (ba + ba)   )
       _UpperCAmelCase					:  Any											=   karatsuba(_UpperCAmelCase      ,     _UpperCAmelCase   )

       return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)

def      UpperCamelCase_							( )   ->   List[str]:


       """simple docstring"""







       print(karatsuba(15_463      ,     23_489   )   )


if __name__ == "__main__":
  main()

