





"""simple docstring"""




from __future__ import annotations

from typing import Generic, TypeVar

lowerCamelCase_	:		Union[str, Any]         =   TypeVar('T')

class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''
      pass


class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''
      pass


class 					_UpperCAmelCase    (  Generic[T]						):



      '''simple docstring'''

      def __init__(	self   , snake_case_ = 1_0    ):

        """simple docstring"""

        A_    :			list[T]									=    []
        A_    :			List[str]									=    limit

      def __bool__(	self    ):

        """simple docstring"""

        return bool(self.stack    )

      def __str__(	self    ):

        """simple docstring"""

        return str(self.stack    )

      def    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

        if len(self.stack    ) >= self.limit:
          raise StackOverflowError
        self.stack.append(snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        if not self.stack:
          raise StackUnderflowError
        return self.stack.pop()

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        if not self.stack:
          raise StackUnderflowError
        return self.stack[-1]

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return not bool(self.stack    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return self.size() == self.limit

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return len(self.stack    )

      def __contains__(	self   , snake_case_    ):

        """simple docstring"""

        return item in self.stack





def 		UpperCAmelCase__						(	):






  """simple docstring"""





  A_    :			Stack[int]									=    Stack(10   )
  assert bool(_UpperCAmelCase   ) is False
  assert stack.is_empty() is True
  assert stack.is_full() is False
  assert str(_UpperCAmelCase   ) == "[]"

  try:
    A_    :			Optional[Any]									=    stack.pop()
    raise AssertionError  # This should not happen
  except StackUnderflowError:
    assert True  # This should happen

  try:
    A_    :			Union[str, Any]									=    stack.peek()
    raise AssertionError  # This should not happen
  except StackUnderflowError:
    assert True  # This should happen

  for i in range(10   ):
    assert stack.size() == i
    stack.push(_UpperCAmelCase   )

  assert bool(_UpperCAmelCase   )
  assert not stack.is_empty()
  assert stack.is_full()
  assert str(_UpperCAmelCase   ) == str(list(range(10   )   )   )
  assert stack.pop() == 9
  assert stack.peek() == 8

  stack.push(100   )
  assert str(_UpperCAmelCase   ) == str([0, 1, 2, 3, 4, 5, 6, 7, 8, 100]   )

  try:
    stack.push(200   )
    raise AssertionError  # This should not happen
  except StackOverflowError:
    assert True  # This should happen

  assert not stack.is_empty()
  assert stack.size() == 10

  assert 5 in stack
  assert 55 not in stack


if __name__ == "__main__":
   test_stack()





def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		int:





  """simple docstring"""





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


def 		_lowerCamelCase					(       )      ->		None:





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