content: from operator import *
  import operator
  
  
  def apply1(f, x, expected):
      return f(x) == expected
  
  
  def apply2(f, lhs, rhs, expected):
      return f(lhs, rhs) == expected
  
  
  n_eq = 0
  n_ne = 0
  n_lt = 0
  n_le = 0
  n_gt = 0
  n_ge = 0
  
  n_len = 0
  n_bool = 0
  
  n_abs = 0
  n_pos = 0
  n_neg = 0
  n_inv = 0
  n_index = 0
  
  n_add = 0
  n_sub = 0
  n_mul = 0
  n_matmul = 0
  n_truediv = 0
  n_floordiv = 0
  n_mod = 0
  n_pow = 0
  n_and = 0
  n_or = 0
  n_xor = 0
  n_lshift = 0
  n_rshift = 0
  
  n_iadd = 0
  n_isub = 0
  n_imul = 0
  n_imatmul = 0
  n_itruediv = 0
  n_ifloordiv = 0
  n_imod = 0
  n_ipow = 0
  n_iand = 0
  n_ior = 0
  n_ixor = 0
  n_ilshift = 0
  n_irshift = 0
  
  
  class C:
      def __eq__(self, other: C):
          global n_eq
          n_eq += 1
          return False
  
      def __ne__(self, other: C):
          global n_ne
          n_ne += 1
          return False
  
      def __lt__(self, other: C):
          global n_lt
          n_lt += 1
          return False
  
      def __le__(self, other: C):
          global n_le
          n_le += 1
          return False
  
      def __gt__(self, other: C):
          global n_gt
          n_gt += 1
          return False
  
      def __ge__(self, other: C):
          global n_ge
          n_ge += 1
          return False
  
      def __len__(self):
          global n_len
          n_len += 1
          return 42
  
      def __bool__(self):
          global n_bool
          n_bool += 1
          return True
  
      def __abs__(self):
          global n_abs
          n_abs += 1
          return "abs"
  
      def __pos__(self):
          global n_pos
          n_pos += 1
          return "pos"
  
      def __neg__(self):
          global n_neg
          n_neg += 1
          return "neg"
  
      def __invert__(self):
          global n_inv
          n_inv += 1
          return "inv"
  
      def __index__(self):
          global n_index
          n_index += 1
          return "index"
  
      def __add__(self, other: C):
          global n_add
          n_add += 1
          return "add"
  
      def __sub__(self, other: C):
          global n_sub
          n_sub += 1
          return "sub"
  
      def __mul__(self, other: C):
          global n_mul
          n_mul += 1
          return "mul"
  
      def __matmul__(self, other: C):
          global n_matmul
          n_matmul += 1
          return "matmul"
  
      def __truediv__(self, other: C):
          global n_truediv
          n_truediv += 1
          return "truediv"
  
      def __floordiv__(self, other: C):
          global n_floordiv
          n_floordiv += 1
          return "floordiv"
  
      def __mod__(self, other: C):
          global n_mod
          n_mod += 1
          return "mod"
  
      def __pow__(self, other: C):
          global n_pow
          n_pow += 1
          return "pow"
  
      def __and__(self, other: C):
          global n_and
          n_and += 1
          return "and"
  
      def __or__(self, other: C):
          global n_or
          n_or += 1
          return "or"
  
      def __xor__(self, other: C):
          global n_xor
          n_xor += 1
          return "xor"
  
      def __lshift__(self, other: C):
          global n_lshift
          n_lshift += 1
          return "lshift"
  
      def __rshift__(self, other: C):
          global n_rshift
          n_rshift += 1
          return "rshift"
  
      def __iadd__(self, other: C):
          global n_iadd
          n_iadd += 1
          return self
  
      def __isub__(self, other: C):
          global n_isub
          n_isub += 1
          return self
  
      def __imul__(self, other: C):
          global n_imul
          n_imul += 1
          return self
  
      def __imatmul__(self, other: C):
          global n_imatmul
          n_imatmul += 1
          return self
  
      def __itruediv__(self, other: C):
          global n_itruediv
          n_itruediv += 1
          return self
  
      def __ifloordiv__(self, other: C):
          global n_ifloordiv
          n_ifloordiv += 1
          return self
  
      def __imod__(self, other: C):
          global n_imod
          n_imod += 1
          return self
  
      def __ipow__(self, other: C):
          global n_ipow
          n_ipow += 1
          return self
  
      def __iand__(self, other: C):
          global n_iand
          n_iand += 1
          return self
  
      def __ior__(self, other: C):
          global n_ior
          n_ior += 1
          return self
  
      def __ixor__(self, other: C):
          global n_ixor
          n_ixor += 1
          return self
  
      def __ilshift__(self, other: C):
          global n_ilshift
          n_ilshift += 1
          return self
  
      def __irshift__(self, other: C):
          global n_irshift
          n_irshift += 1
          return "rshift"
  
  
  @test
  def test_comparisons():
      assert apply2(eq, 1, 2, False)
      assert apply2(eq, 2, 1, False)
      assert apply2(eq, 1, 1, True)
      assert apply2(eq, 1, 1.1, False)
  
      assert apply2(operator.__eq__, 1, 2, False)
      assert apply2(operator.__eq__, 2, 1, False)
      assert apply2(operator.__eq__, 1, 1, True)
      assert apply2(operator.__eq__, 1, 1.1, False)
  
      assert apply2(ne, 1, 2, True)
      assert apply2(ne, 2, 1, True)
      assert apply2(ne, 1, 1, False)
      assert apply2(ne, 1, 1.1, True)
  
      assert apply2(operator.__ne__, 1, 2, True)
      assert apply2(operator.__ne__, 2, 1, True)
      assert apply2(operator.__ne__, 1, 1, False)
      assert apply2(operator.__ne__, 1, 1.1, True)
  
      assert apply2(lt, 1, 2, True)
      assert apply2(lt, 2, 1, False)
      assert apply2(lt, 1, 1, False)
      assert apply2(lt, 1, 1.1, True)
  
      assert apply2(operator.__lt__, 1, 2, True)
      assert apply2(operator.__lt__, 2, 1, False)
      assert apply2(operator.__lt__, 1, 1, False)
      assert apply2(operator.__lt__, 1, 1.1, True)
  
      assert apply2(le, 1, 2, True)
      assert apply2(le, 2, 1, False)
      assert apply2(le, 1, 1, True)
      assert apply2(le, 1, 1.1, True)
  
      assert apply2(operator.__le__, 1, 2, True)
      assert apply2(operator.__le__, 2, 1, False)
      assert apply2(operator.__le__, 1, 1, True)
      assert apply2(operator.__le__, 1, 1.1, True)
  
      assert apply2(gt, 1, 2, False)
      assert apply2(gt, 2, 1, True)
      assert apply2(gt, 1, 1, False)
      assert apply2(gt, 1, 1.1, False)
  
      assert apply2(operator.__gt__, 1, 2, False)
      assert apply2(operator.__gt__, 2, 1, True)
      assert apply2(operator.__gt__, 1, 1, False)
      assert apply2(operator.__gt__, 1, 1.1, False)
  
      assert apply2(ge, 1, 2, False)
      assert apply2(ge, 2, 1, True)
      assert apply2(ge, 1, 1, True)
      assert apply2(ge, 1, 1.1, False)
  
      assert apply2(operator.__ge__, 1, 2, False)
      assert apply2(operator.__ge__, 2, 1, True)
      assert apply2(operator.__ge__, 1, 1, True)
      assert apply2(operator.__ge__, 1, 1.1, False)
  
      assert apply2(eq, C(), C(), False)
      assert n_eq == 1
      assert apply2(ne, C(), C(), False)
      assert n_ne == 1
      assert apply2(lt, C(), C(), False)
      assert n_lt == 1
      assert apply2(le, C(), C(), False)
      assert n_le == 1
      assert apply2(gt, C(), C(), False)
      assert n_gt == 1
      assert apply2(ge, C(), C(), False)
      assert n_ge == 1
  
      assert apply2(operator.__eq__, C(), C(), False)
      assert n_eq == 2
      assert apply2(operator.__ne__, C(), C(), False)
      assert n_ne == 2
      assert apply2(operator.__lt__, C(), C(), False)
      assert n_lt == 2
      assert apply2(operator.__le__, C(), C(), False)
      assert n_le == 2
      assert apply2(operator.__gt__, C(), C(), False)
      assert n_gt == 2
      assert apply2(operator.__ge__, C(), C(), False)
      assert n_ge == 2
  
  
  test_comparisons()
  
  
  class A1:
      def __bool__(self):
          return True
  
      def __len__(self):
          return 0
  
  
  class A2:
      def __len__(self):
          return 42
  
  
  @test
  def test_truthiness():
      assert truth(1)
      assert not truth(0)
      assert not_(False)
      assert not not_(True)
      assert not not_(A1())
      assert not not_(A2())
  
      a = A1()
      b = A1()
  
      assert is_(a, a)
      assert not is_(a, b)
      assert is_not(a, b)
      assert not is_not(a, a)
  
      assert truth(C())
      assert n_bool == 1
  
  
  test_truthiness()
  
  
  @test
  def test_ops():
      x = C()
      y = C()
  
      assert abs(x) == "abs"
      assert n_abs == 1
      assert operator.__abs__(x) == "abs"
      assert n_abs == 2
  
      assert pos(x) == "pos"
      assert n_pos == 1
      assert operator.__pos__(x) == "pos"
      assert n_pos == 2
  
      assert neg(x) == "neg"
      assert n_neg == 1
      assert operator.__neg__(x) == "neg"
      assert n_neg == 2
  
      assert inv(x) == "inv"
      assert n_inv == 1
      assert operator.__inv__(x) == "inv"
      assert n_inv == 2
      assert invert(x) == "inv"
      assert n_inv == 3
      assert operator.__invert__(x) == "inv"
      assert n_inv == 4
  
      assert index(x) == "index"
      assert n_index == 1
      assert operator.__index__(x) == "index"
      assert n_index == 2
  
      assert add(x, y) == "add"
      assert n_add == 1
      assert operator.__add__(x, y) == "add"
      assert n_add == 2
  
      assert iadd(x, y) is x
      assert n_iadd == 1
      assert operator.__iadd__(x, y) is x
      assert n_iadd == 2
  
      assert sub(x, y) == "sub"
      assert n_sub == 1
      assert operator.__sub__(x, y) == "sub"
      assert n_sub == 2
  
      assert isub(x, y) is x
      assert n_isub == 1
      assert operator.__isub__(x, y) is x
      assert n_isub == 2
  
      assert mul(x, y) == "mul"
      assert n_mul == 1
      assert operator.__mul__(x, y) == "mul"
      assert n_mul == 2
  
      assert imul(x, y) is x
      assert n_imul == 1
      assert operator.__imul__(x, y) is x
      assert n_imul == 2
  
      assert matmul(x, y) == "matmul"
      assert n_matmul == 1
      assert operator.__matmul__(x, y) == "matmul"
      assert n_matmul == 2
  
      assert imatmul(x, y) is x
      assert n_imatmul == 1
      assert operator.__imatmul__(x, y) is x
      assert n_imatmul == 2
  
      assert truediv(x, y) == "truediv"
      assert n_truediv == 1
      assert operator.__truediv__(x, y) == "truediv"
      assert n_truediv == 2
  
      assert itruediv(x, y) is x
      assert n_itruediv == 1
      assert operator.__itruediv__(x, y) is x
      assert n_itruediv == 2
  
      assert floordiv(x, y) == "floordiv"
      assert n_floordiv == 1
      assert operator.__floordiv__(x, y) == "floordiv"
      assert n_floordiv == 2
  
      assert ifloordiv(x, y) is x
      assert n_ifloordiv == 1
      assert operator.__ifloordiv__(x, y) is x
      assert n_ifloordiv == 2
  
      assert mod(x, y) == "mod"
      assert n_mod == 1
      assert operator.__mod__(x, y) == "mod"
      assert n_mod == 2
  
      assert imod(x, y) is x
      assert n_imod == 1
      assert operator.__imod__(x, y) is x
      assert n_imod == 2
  
      assert pow(x, y) == "pow"
      assert n_pow == 1
      assert operator.__pow__(x, y) == "pow"
      assert n_pow == 2
  
      assert ipow(x, y) is x
      assert n_ipow == 1
      assert operator.__ipow__(x, y) is x
      assert n_ipow == 2
  
      assert and_(x, y) == "and"
      assert n_and == 1
      assert operator.__and__(x, y) == "and"
      assert n_and == 2
  
      assert iand(x, y) is x
      assert n_iand == 1
      assert operator.__iand__(x, y) is x
      assert n_iand == 2
  
      assert or_(x, y) == "or"
      assert n_or == 1
      assert operator.__or__(x, y) == "or"
      assert n_or == 2
  
      assert ior(x, y) is x
      assert n_ior == 1
      assert operator.__ior__(x, y) is x
      assert n_ior == 2
  
      assert xor(x, y) == "xor"
      assert n_xor == 1
      assert operator.__xor__(x, y) == "xor"
      assert n_xor == 2
  
      assert ixor(x, y) is x
      assert n_ixor == 1
      assert operator.__ixor__(x, y) is x
      assert n_ixor == 2
  
      assert lshift(x, y) == "lshift"
      assert n_lshift == 1
      assert operator.__lshift__(x, y) == "lshift"
      assert n_lshift == 2
  
      assert ilshift(x, y) is x
      assert n_ilshift == 1
      assert operator.__ilshift__(x, y) is x
      assert n_ilshift == 2
  
      assert rshift(x, y) == "rshift"
      assert n_rshift == 1
      assert operator.__rshift__(x, y) == "rshift"
      assert n_rshift == 2
  
      assert irshift(x, y) is x
      assert n_irshift == 1
      assert operator.__irshift__(x, y) is x
      assert n_irshift == 2
  
  
  test_ops()
  
  
  class B1:
      def __length_hint__(self):
          return 101
  
  
  class B2:
      def __length_hint__(self):
          return 202
  
      def __len__(self):
          return 303
  
  
  class B3:
      pass
  
  
  @test
  def test_sequence_ops():
      assert concat([1, 2], [3, 4]) == [1, 2, 3, 4]
      assert operator.__concat__([1, 2], [3, 4]) == [1, 2, 3, 4]
      assert contains([1, 2, 3], 2)
      assert not contains([1, 2, 3], 0)
      assert operator.__contains__([1, 2, 3], 2)
      assert not operator.__contains__([1, 2, 3], 0)
      assert countOf([1, 2, 1, 1], 1) == 3
  
      v = [1, 2, 3]
      assert getitem(v, 1) == 2
      delitem(v, 1)
      assert v == [1, 3]
      setitem(v, 1, 99)
      assert v == [1, 99]
  
      assert length_hint(B1()) == 101
      assert length_hint(B2()) == 303
      assert length_hint(B3()) == 0
      assert length_hint(B3(), default=404) == 404
  
      assert itemgetter(-1)([11, 22, 33]) == 33
      assert itemgetter(-1, -2, -3)([11, 22, 33]) == (33, 22, 11)
  
  
  test_sequence_ops()
  
  
  class C:
      foo: int
  
      def __init__(self, foo):
          self.foo = foo
  
      def bar(self, k, m, n):
          return self.foo + k + m*100 + n*1000
  
  
  @test
  def test_getter_ops():
      v = ['a']
      operator.attrgetter('append')(v)('hello')
      operator.methodcaller('append', 'goodbye')(v)
      assert v == ['a', 'hello', 'goodbye']
  
      c = C(10)
      assert operator.attrgetter('foo')(c) == 10
      assert operator.methodcaller('bar', 9, n=7, m=3)(c) == 7319
  
  
  test_getter_ops()
  