


'''simple docstring'''


from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize





class 					lowercase__						(		SCREAMING_SNAKE_CASE__      ):





							'''simple docstring'''


							A_							:   Dict   			=						1
							A_							:   Any   			=						2
							A_							:   int   			=						3






							def __repr__(					self						):
											return f"""{self.__class__.__name__}.{self.name}"""







def     snake_case_     (						SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[int]  	=   point
				return degrees(atana(y - miny							,   x - minx  )  )







def     snake_case_     (						SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: int  	=   starting
				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[Any]  	=   via
				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: List[Any]  	=   target
				_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   degrees(atana(ya - ya							,   xa - xa  )  )
				via_angle %= 360
				_SCREAMING_SNAKE_CASE				: Any  	=   degrees(atana(ya - ya							,   xa - xa  )  )
				target_angle %= 360
				# t-
				#  \ \
				#   \ v
				#    \|
				#     s
				# via_angle is always lower than target_angle, if direction is left.
				# If they are same, it means they are on a same line of convex hull.
				if target_angle > via_angle:
								return Direction.left
				elif target_angle == via_angle:
								return Direction.straight
				else:
								return Direction.right







def     snake_case_     (						SCREAMING_SNAKE_CASE__  ):







				"""simple docstring"""





				if len(SCREAMING_SNAKE_CASE__  ) <= 2:
								# There is no convex hull
								raise ValueError("""graham_scan: argument must contain more than 3 points."""  )
				if len(SCREAMING_SNAKE_CASE__  ) == 3:
								return points
				# find the lowest and the most left point
				_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   0
				_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   maxsize, maxsize
				for i, point in enumerate(SCREAMING_SNAKE_CASE__  ):
								_SCREAMING_SNAKE_CASE				: Tuple  	=   point[0]
								_SCREAMING_SNAKE_CASE				: int  	=   point[1]
								if y < miny:
												_SCREAMING_SNAKE_CASE				: str  	=   y
												_SCREAMING_SNAKE_CASE				: Optional[int]  	=   x
												_SCREAMING_SNAKE_CASE				: Any  	=   i
								if y == miny and x < minx:
												_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   x
												_SCREAMING_SNAKE_CASE				: Any  	=   i

    # remove the lowest and the most left point from points for preparing for sort
				points.pop(SCREAMING_SNAKE_CASE__  )

				_SCREAMING_SNAKE_CASE				: Tuple  	=   sorted(SCREAMING_SNAKE_CASE__							,   key=lambda SCREAMING_SNAKE_CASE__  : angle_comparer(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )  )
				# This insert actually costs complexity,
				# and you should instead add (minx, miny) into stack later.
				# I'm using insert just for easy understanding.
				sorted_points.insert(0							,   (minx, miny)  )

				_SCREAMING_SNAKE_CASE				: Any  	=   deque()
				stack.append(sorted_points[0]  )
				stack.append(sorted_points[1]  )
				stack.append(sorted_points[2]  )
				# In any ways, the first 3 points line are towards left.
				# Because we sort them the angle from minx, miny.
				_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   Direction.left

				for i in range(3							,   len(SCREAMING_SNAKE_CASE__  )  ):
								while True:
												_SCREAMING_SNAKE_CASE				: List[str]  	=   stack[-2]
												_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   stack[-1]
												_SCREAMING_SNAKE_CASE				: str  	=   sorted_points[i]
												_SCREAMING_SNAKE_CASE				: str  	=   check_direction(SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  )

												if next_direction == Direction.left:
																_SCREAMING_SNAKE_CASE				: Dict  	=   Direction.left
																break
												if next_direction == Direction.straight:
																if current_direction == Direction.left:
																				# We keep current_direction as left.
																				# Because if the straight line keeps as straight,
																				# we want to know if this straight line is towards left.
																				break
																elif current_direction == Direction.right:
																				# If the straight line is towards right,
																				# every previous points on those straigh line is not convex hull.
																				stack.pop()
												if next_direction == Direction.right:
																stack.pop()
								stack.append(sorted_points[i]  )
				return list(SCREAMING_SNAKE_CASE__  )








'''simple docstring'''


def     snake_case_     (						SCREAMING_SNAKE_CASE__							,   SCREAMING_SNAKE_CASE__  ):







				"""simple docstring"""





				return (input_a, input_a).count(0  ) % 2







def     snake_case_     (						):







				"""simple docstring"""





				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))




