from typing import Any



class 						snake_case_ :






   def __init__(   self       :  List[Any]						)      ->		Dict:
       lowercase__				:     List[str]					      =       []
       lowercase__				:     Optional[int]					      =       0






   def __str__(   self       :  Optional[Any]						)      ->		Any:
       lowercase__				:     Optional[Any]					      =       "<" + str(self.stack						)[1:-1] + ">"
       return printed






   def    __UpperCamelCase  (   self       :  List[str]			,		lowercase_       :  Any						)      ->		Tuple:
       self.stack.append(lowercase_						)
       lowercase__				:     Optional[Any]					      =       self.length + 1






   def    __UpperCamelCase  (   self       :  List[Any]						)      ->		int:
       self.rotate(1						)
       lowercase__				:     Optional[int]					      =       self.stack[self.length - 1]
       lowercase__				:     Optional[Any]					      =       self.stack[:-1]
       self.rotate(self.length - 1						)
       lowercase__				:     str					      =       self.length - 1
       return dequeued






   def    __UpperCamelCase  (   self       :  Optional[Any]			,		lowercase_       :  int						)      ->		Any:






       for _ in range(lowercase_						):
           lowercase__				:     Any					      =       self.stack[0]
           lowercase__				:     str					      =       self.stack[1:]
           self.put(lowercase_						)
           lowercase__				:     Optional[Any]					      =       self.length - 1






   def    __UpperCamelCase  (   self       :  str						)      ->		List[Any]:
       lowercase__				:     List[str]					      =       self.get()
       self.put(lowercase_						)
       self.rotate(self.length - 1						)
       return front







   def    __UpperCamelCase  (   self       :  Optional[Any]						)      ->		Optional[Any]:
       return self.length




def     lowercase_       (    _lowerCamelCase							: str	,			_lowerCamelCase							: Optional[int]):
    if len(str(_lowerCamelCase)) == 1 or len(str(_lowerCamelCase)) == 1:
        return a * b

    lowercase__				:     Tuple					      =       max(len(str(_lowerCamelCase))	,			len(str(_lowerCamelCase)))
    lowercase__				:     Union[str, Any]					      =       ma // 2

    lowercase__      ,     lowercase__				:     Union[str, Any]					      =       divmod(_lowerCamelCase	,			10**ma)
    lowercase__      ,     lowercase__				:     Tuple					      =       divmod(_lowerCamelCase	,			10**ma)

    lowercase__				:     int					      =       karatsuba(_lowerCamelCase	,			_lowerCamelCase)
    lowercase__				:     Dict					      =       karatsuba((aa + aa)	,			(ba + ba))
    lowercase__				:     Optional[int]					      =       karatsuba(_lowerCamelCase	,			_lowerCamelCase)

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

def     lowercase_       (    ):
    print(karatsuba(1_5463	,			2_3489))


if __name__ == "__main__":
      main()



