# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Operator interface.

This module exports a set of functions implemented in C corresponding
to the intrinsic operators of Python.  For example, operator.add(x, y)
is equivalent to the expression x+y.  The function names are those
used for special methods; variants without leading and trailing
'__' are also provided for convenience. """

__doc__ = """Operator interface.

This module exports a set of functions implemented in C corresponding
to the intrinsic operators of Python.  For example, operator.add(x, y)
is equivalent to the expression x+y.  The function names are those
used for special methods; variants without leading and trailing
'__' are also provided for convenience."""

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_module(self, fullname, path=None):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
            This method is deprecated.  Use find_spec() instead.
    
             """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
        This method is deprecated.  Use loader.exec_module instead.
    
         """
    pass

  def module_repr(self, module):
    """ Return repr for the module.
    
            The method is deprecated.  The import machinery does the job itself.
    
             """
    pass

__name__ = '_operator'
__package__ = ''
__spec__ = None

def _compare_digest(a, b):
  """ compare_digest(a, b) -> bool
  
  Return 'a == b'.  This function uses an approach designed to prevent
  timing analysis, making it appropriate for cryptography.
  a and b must both be of the same type: either str (ASCII only),
  or any bytes-like object.
  
  Note: If a and b are of different lengths, or if an error occurs,
  a timing attack could theoretically reveal information about the
  types and lengths of a and b--but not their values.
   """
  return None

def abs(a):
  """ abs(a) -- Same as abs(a). """
  return None

def add(a, b):
  """ add(a, b) -- Same as a + b. """
  return None

def and_(a, b):
  """ and_(a, b) -- Same as a & b. """
  return None

class attrgetter(object):
  """ attrgetter(attr, ...) --> attrgetter object
  
  Return a callable object that fetches the given attribute(s) from its operand.
  After f = attrgetter('name'), the call f(r) returns r.name.
  After g = attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).
  After h = attrgetter('name.first', 'name.last'), the call h(r) returns
  (r.name.first, r.name.last). """

  pass

def concat(a, b):
  """ concat(a, b) -- Same as a + b, for a and b sequences. """
  return None

def contains(a, b):
  """ contains(a, b) -- Same as b in a (note reversed operands). """
  return None

def countOf(a, b):
  """ countOf(a, b) -- Return the number of times b occurs in a. """
  return None

def delitem(a, b):
  """ delitem(a, b) -- Same as del a[b]. """
  return None

def eq(a, b):
  """ eq(a, b) -- Same as a==b. """
  return None

def floordiv(a, b):
  """ floordiv(a, b) -- Same as a // b. """
  return None

def ge(a, b):
  """ ge(a, b) -- Same as a>=b. """
  return None

def getitem(a, b):
  """ getitem(a, b) -- Same as a[b]. """
  return None

def gt(a, b):
  """ gt(a, b) -- Same as a>b. """
  return None

def iadd(a, b):
  """ a = iadd(a, b) -- Same as a += b. """
  return None

def iand(a, b):
  """ a = iand(a, b) -- Same as a &= b. """
  return None

def iconcat(a, b):
  """ a = iconcat(a, b) -- Same as a += b, for a and b sequences. """
  return None

def ifloordiv(a, b):
  """ a = ifloordiv(a, b) -- Same as a //= b. """
  return None

def ilshift(a, b):
  """ a = ilshift(a, b) -- Same as a <<= b. """
  return None

def imatmul(a, b):
  """ a = imatmul(a, b) -- Same as a @= b. """
  return None

def imod(a, b):
  """ a = imod(a, b) -- Same as a %= b. """
  return None

def imul(a, b):
  """ a = imul(a, b) -- Same as a *= b. """
  return None

def index(a):
  """ index(a) -- Same as a.__index__() """
  return None

def indexOf(a, b):
  """ indexOf(a, b) -- Return the first index of b in a. """
  return None

def inv(a):
  """ inv(a) -- Same as ~a. """
  return None

def invert(a):
  """ invert(a) -- Same as ~a. """
  return None

def ior(a, b):
  """ a = ior(a, b) -- Same as a |= b. """
  return None

def ipow(a, b):
  """ a = ipow(a, b) -- Same as a **= b. """
  return None

def irshift(a, b):
  """ a = irshift(a, b) -- Same as a >>= b. """
  return None

def is_(a, b):
  """ is_(a, b) -- Same as a is b. """
  return None

def is_not(a, b):
  """ is_not(a, b) -- Same as a is not b. """
  return None

def isub(a, b):
  """ a = isub(a, b) -- Same as a -= b. """
  return None

class itemgetter(object):
  """ itemgetter(item, ...) --> itemgetter object
  
  Return a callable object that fetches the given item(s) from its operand.
  After f = itemgetter(2), the call f(r) returns r[2].
  After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3]) """

  pass

def itruediv(a, b):
  """ a = itruediv(a, b) -- Same as a /= b """
  return None

def ixor(a, b):
  """ a = ixor(a, b) -- Same as a ^= b. """
  return None

def le(a, b):
  """ le(a, b) -- Same as a<=b. """
  return None

def length_hint(obj, default=0):
  """ length_hint(obj, default=0) -> int
  Return an estimate of the number of items in obj.
  This is useful for presizing containers when building from an
  iterable.
  
  If the object supports len(), the result will be
  exact. Otherwise, it may over- or under-estimate by an
  arbitrary amount. The result will be an integer >= 0. """
  return 1

def lshift(a, b):
  """ lshift(a, b) -- Same as a << b. """
  return None

def lt(a, b):
  """ lt(a, b) -- Same as a<b. """
  return None

def matmul(a, b):
  """ matmul(a, b) -- Same as a @ b. """
  return None

class methodcaller(object):
  """ methodcaller(name, ...) --> methodcaller object
  
  Return a callable object that calls the given method on its operand.
  After f = methodcaller('name'), the call f(r) returns r.name().
  After g = methodcaller('name', 'date', foo=1), the call g(r) returns
  r.name('date', foo=1). """

  pass

def mod(a, b):
  """ mod(a, b) -- Same as a % b. """
  return None

def mul(a, b):
  """ mul(a, b) -- Same as a * b. """
  return None

def ne(a, b):
  """ ne(a, b) -- Same as a!=b. """
  return None

def neg(a):
  """ neg(a) -- Same as -a. """
  return None

def not_(a):
  """ not_(a) -- Same as not a. """
  return None

def or_(a, b):
  """ or_(a, b) -- Same as a | b. """
  return None

def pos(a):
  """ pos(a) -- Same as +a. """
  return None

def pow(a, b):
  """ pow(a, b) -- Same as a ** b. """
  return None

def rshift(a, b):
  """ rshift(a, b) -- Same as a >> b. """
  return None

def setitem(a, b, c):
  """ setitem(a, b, c) -- Same as a[b] = c. """
  return None

def sub(a, b):
  """ sub(a, b) -- Same as a - b. """
  return None

def truediv(a, b):
  """ truediv(a, b) -- Same as a / b. """
  return None

def truth(a):
  """ truth(a) -- Return True if a is true, False otherwise. """
  return None

def xor(a, b):
  """ xor(a, b) -- Same as a ^ b. """
  return None