

'''simple docstring'''





def   _UpperCamelCase	(		__UpperCamelCase    ,__UpperCamelCase	)       ->			int:
					while second != 0:
										lowerCamelCase_  				=      first & second
										first ^= second
										lowerCamelCase_  				=      c << 1
					return first


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				A_	= int(input("Enter the first number: ").strip())
				A_	= int(input("Enter the second number: ").strip())
				print(f'''{add(first, second) = }''')




import logging
import os

from .state import PartialState
class     lowerCAmelCase_     (       logging.LoggerAdapter ):







							@staticmethod
							def  UpperCamelCase_						(   _A      :     Any		):
												_UpperCamelCase			     =     PartialState()
												return not main_process_only or (main_process_only and state.is_main_process)







							def  UpperCamelCase_						(   self      :     Union[str, Any] ,			_A      :     Optional[Any] ,			_A      :     str ,			*_A      :     int ,			**_A      :     List[Any]		):
												if PartialState._shared_state == {}:
																	raise RuntimeError(
																	    '''You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility.'''		)
												_UpperCamelCase			     =     kwargs.pop('''main_process_only''' ,			_A		)
												_UpperCamelCase			     =     kwargs.pop('''in_order''' ,			_A		)

												if self.isEnabledFor(_A		):
																	if self._should_log(_A		):
																						_UpperCamelCase     ,    _UpperCamelCase			     =     self.process(_A ,			_A		)
																						self.logger.log(_A ,			_A ,			*_A ,			**_A		)

																	elif in_order:
																						_UpperCamelCase			     =     PartialState()
																						for i in range(state.num_processes		):
																											if i == state.process_index:
																																_UpperCamelCase     ,    _UpperCamelCase			     =     self.process(_A ,			_A		)
																																self.logger.log(_A ,			_A ,			*_A ,			**_A		)
																											state.wait_for_everyone()




def 					_snake_case	(  __snake_case  ,     __snake_case = None						):
					if log_level is None:
										_UpperCamelCase			     =     os.environ.get('''ACCELERATE_LOG_LEVEL'''  ,     __snake_case						)
					_UpperCamelCase			     =     logging.getLogger(__snake_case						)
					if log_level is not None:
										logger.setLevel(log_level.upper()						)
										logger.root.setLevel(log_level.upper()						)
					return MultiProcessAdapter(__snake_case  ,     {}						)
