
from ..utils import DummyObject, requires_backends




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  Any,			**_snake_case  :  Tuple )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Union[str, Any],			*_snake_case  :  Dict,			**_snake_case  :  int )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  List[Any],			**_snake_case  :  Union[str, Any] )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Union[str, Any],			*_snake_case  :  Optional[int],			**_snake_case  :  str )       ->Union[str, Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[Any],			*_snake_case  :  List[Any],			**_snake_case  :  Dict )       ->Optional[Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[int],			*_snake_case  :  Optional[int],			**_snake_case  :  List[str] )       ->Tuple:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[int],			*_snake_case  :  str,			**_snake_case  :  int )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  List[str],			**_snake_case  :  Any )       ->Dict:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  str,			*_snake_case  :  Optional[int],			**_snake_case  :  List[str] )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  str,			*_snake_case  :  Dict,			**_snake_case  :  Tuple )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  int,			**_snake_case  :  Optional[Any] )       ->str:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Dict,			*_snake_case  :  List[Any],			**_snake_case  :  Optional[Any] )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[int],			*_snake_case  :  Tuple,			**_snake_case  :  List[Any] )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Dict,			*_snake_case  :  str,			**_snake_case  :  List[str] )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  List[Any],			**_snake_case  :  str )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  List[str],			**_snake_case  :  Dict )       ->Union[str, Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Union[str, Any],			*_snake_case  :  List[Any],			**_snake_case  :  List[Any] )       ->Dict:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  Optional[int],			**_snake_case  :  List[Any] )       ->List[Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  str,			**_snake_case  :  Optional[Any] )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[Any],			*_snake_case  :  List[Any],			**_snake_case  :  Optional[int] )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  Union[str, Any],			**_snake_case  :  Union[str, Any] )       ->Union[str, Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[Any],			*_snake_case  :  Any,			**_snake_case  :  Union[str, Any] )       ->str:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Dict,			*_snake_case  :  List[str],			**_snake_case  :  Union[str, Any] )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[int],			*_snake_case  :  List[Any],			**_snake_case  :  str )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[int],			*_snake_case  :  Dict,			**_snake_case  :  str )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Union[str, Any],			*_snake_case  :  Tuple,			**_snake_case  :  Union[str, Any] )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Union[str, Any],			*_snake_case  :  Dict,			**_snake_case  :  Any )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[int],			*_snake_case  :  int,			**_snake_case  :  List[str] )       ->str:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  Tuple,			**_snake_case  :  Any )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  int,			**_snake_case  :  Optional[Any] )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  List[Any],			**_snake_case  :  Optional[Any] )       ->str:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Tuple,			*_snake_case  :  Tuple,			**_snake_case  :  int )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  Dict,			**_snake_case  :  Dict )       ->Dict:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Dict,			*_snake_case  :  Dict,			**_snake_case  :  Tuple )       ->Optional[Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  Optional[int],			**_snake_case  :  Optional[int] )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Tuple,			*_snake_case  :  Dict,			**_snake_case  :  Dict )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  str,			*_snake_case  :  str,			**_snake_case  :  List[Any] )       ->Union[str, Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  List[Any],			**_snake_case  :  int )       ->Union[str, Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Union[str, Any],			*_snake_case  :  Optional[Any],			**_snake_case  :  Optional[int] )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  int,			**_snake_case  :  Optional[int] )       ->str:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  Dict,			**_snake_case  :  Tuple )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Tuple,			*_snake_case  :  Tuple,			**_snake_case  :  Any )       ->Any:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[Any],			*_snake_case  :  Optional[int],			**_snake_case  :  List[Any] )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  Tuple,			**_snake_case  :  Tuple )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[str],			*_snake_case  :  Any,			**_snake_case  :  Any )       ->Dict:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[Any],			*_snake_case  :  int,			**_snake_case  :  Tuple )       ->Tuple:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Dict,			*_snake_case  :  Dict,			**_snake_case  :  int )       ->Tuple:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  Dict,			**_snake_case  :  int )       ->str:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Optional[Any],			*_snake_case  :  List[Any],			**_snake_case  :  Any )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[Any],			*_snake_case  :  int,			**_snake_case  :  int )       ->List[Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  Dict,			**_snake_case  :  Tuple )       ->Optional[Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  str,			*_snake_case  :  Optional[Any],			**_snake_case  :  Optional[int] )       ->Optional[Any]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Tuple,			*_snake_case  :  Any,			**_snake_case  :  Optional[Any] )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  int,			*_snake_case  :  Optional[Any],			**_snake_case  :  Dict )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Dict,			*_snake_case  :  List[str],			**_snake_case  :  Tuple )       ->List[str]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Any,			*_snake_case  :  Any,			**_snake_case  :  Dict )       ->int:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  List[Any],			*_snake_case  :  Dict,			**_snake_case  :  int )       ->Optional[int]:
            requires_backends(self,			['tokenizers'] )




class  snake_case__						(	metaclass=lowerCAmelCase_					):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE            =     ["""tokenizers"""]






     def __init__(	self  :  Tuple,			*_snake_case  :  Optional[int],			**_snake_case  :  List[Any] )       ->Any:
            requires_backends(self,			['tokenizers'] )











def 	lowercase_							(A			:			int		, A			:			int				):
       return (input_a, input_a).count(0				) % 2
def 	lowercase_							():
       assert xor_gate(0		, 0				) == 0
       assert xor_gate(0		, 1				) == 1
       assert xor_gate(1		, 0				) == 1
       assert xor_gate(1		, 1				) == 0


if __name__ == "__main__":
 print(xor_gate(0, 0))
 print(xor_gate(0, 1))






