# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT
# OVERRIDES FILE: static-pi-files/2.6/__builtin__override.py

""" Built-in functions, exceptions, and other objects.

Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices. """

class ArithmeticError(StandardError):
  """ Base class for arithmetic errors. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class AssertionError(StandardError):
  """ Assertion failed. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class AttributeError(StandardError):
  """ Attribute not found. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class BaseException(object):
  """ Common base class for all exceptions """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  args = property(None, None, None,
                  )

  message = property(None, None, None,
                     )


class BufferError(StandardError):
  """ Buffer error. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class BytesWarning(Warning):
  """ Base class for warnings about bytes and buffer related problems, mostly
  related to conversion from str or comparing to str. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class DeprecationWarning(Warning):
  """ Base class for warnings about deprecated features. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class EOFError(StandardError):
  """ Read beyond end of file. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

Ellipsis = Ellipsis

class EnvironmentError(StandardError):
  """ Base class for I/O related errors. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  errno = None
  filename = None
  strerror = None

class Exception(BaseException):
  """ Common base class for all non-exit exceptions. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

False = False

class FloatingPointError(ArithmeticError):
  """ Floating point operation failed. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class FutureWarning(Warning):
  """ Base class for warnings about constructs that will change semantically
  in the future. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class GeneratorExit(BaseException):
  """ Request that a generator exit. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class IOError(EnvironmentError):
  """ I/O operation failed. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class ImportError(StandardError):
  """ Import can't find module, or can't find name in module. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class ImportWarning(Warning):
  """ Base class for warnings about probable mistakes in module imports """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class IndentationError(SyntaxError):
  """ Improper indentation. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class IndexError(LookupError):
  """ Sequence index out of range. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class KeyError(LookupError):
  """ Mapping key not found. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class KeyboardInterrupt(BaseException):
  """ Program interrupted by user. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class LookupError(StandardError):
  """ Base class for lookup errors. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class MemoryError(StandardError):
  """ Out of memory. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class NameError(StandardError):
  """ Name not found globally. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

None = None
NotImplemented = None

class NotImplementedError(RuntimeError):
  """ Method or function hasn't been implemented yet. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class OSError(EnvironmentError):
  """ OS system call failed. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class OverflowError(ArithmeticError):
  """ Result too large to be represented. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class PendingDeprecationWarning(Warning):
  """ Base class for warnings about features which will be deprecated
  in the future. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class ReferenceError(StandardError):
  """ Weak ref proxy used after referent went away. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class RuntimeError(StandardError):
  """ Unspecified run-time error. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class RuntimeWarning(Warning):
  """ Base class for warnings about dubious runtime behavior. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class StandardError(Exception):
  """ Base class for all standard Python exceptions that do not represent
  interpreter exiting. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class StopIteration(Exception):
  """ Signal the end from iterator.next(). """

  def __init__(self):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class SyntaxError(StandardError):
  """ Invalid syntax. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  filename = None
  lineno = None
  msg = None
  offset = None
  print_file_and_line = None
  text = None

class SyntaxWarning(Warning):
  """ Base class for warnings about dubious syntax. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class SystemError(StandardError):
  """ Internal error in the Python interpreter.
  
  Please report this to the Python maintainer, along with the traceback,
  the Python version, and the hardware/OS platform and version. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class SystemExit(BaseException):
  """ Request to exit from the interpreter. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  code = None

class TabError(IndentationError):
  """ Improper mixture of spaces and tabs. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

True = True

class TypeError(StandardError):
  """ Inappropriate argument type. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class UnboundLocalError(NameError):
  """ Local name referenced but not bound to a value. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class UnicodeDecodeError(UnicodeError):
  """ Unicode decoding error. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  encoding = None
  end = None
  object = None
  reason = None
  start = None

class UnicodeEncodeError(UnicodeError):
  """ Unicode encoding error. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  encoding = None
  end = None
  object = None
  reason = None
  start = None

class UnicodeError(ValueError):
  """ Unicode related error. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class UnicodeTranslateError(UnicodeError):
  """ Unicode translation error. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

  encoding = None
  end = None
  object = None
  reason = None
  start = None

class UnicodeWarning(Warning):
  """ Base class for warnings about Unicode related problems, mostly
  related to conversion problems. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class UserWarning(Warning):
  """ Base class for warnings generated by user code. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class ValueError(StandardError):
  """ Inappropriate argument value (of correct type). """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class Warning(Exception):
  """ Base class for warning categories. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

class ZeroDivisionError(ArithmeticError):
  """ Second argument to a division or modulo operation was zero. """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

__debug__ = True

def abs(number):
  """ abs(number) -> number
  
  Return the absolute value of the argument. """
  return None

def all(iterable):
  """ all(iterable) -> bool
  
  Return True if bool(x) is True for all values x in the iterable. """
  return None

def any(iterable):
  """ any(iterable) -> bool
  
  Return True if bool(x) is True for any x in the iterable. """
  return None

def apply(object, args=None, kwargs=None):
  """ apply(object[, args[, kwargs]]) -> value
  
  Call a callable object with positional arguments taken from the tuple args,
  and keyword arguments taken from the optional dictionary kwargs.
  Note that classes are callable, as are instances with a __call__() method.
  
  Deprecated since release 2.3. Instead, use the extended call syntax:
      function(*args, **keywords). """
  return None

class basestring(object):
  """ Type basestring cannot be instantiated; it is the base for str and unicode. """

  # BEGIN MANUAL OVERRIDES FROM static-pi-files/2.6/__builtin__override.py
  # END MANUAL OVERRIDES
  pass

def bin(number):
  """ bin(number) -> string
  
  Return the binary representation of an integer or long integer. """
  return ""

class bool(int):
  """ bool(x) -> bool
  
  Returns True when the argument x is true, False otherwise.
  The builtins True and False are the only two instances of the class bool.
  The class bool is a subclass of the class int, and cannot be subclassed. """

  pass

class buffer(object):
  """ buffer(object [, offset[, size]])
  
  Create a new buffer object which references the given object.
  The buffer will reference a slice of the target object from the
  start of the object (or at the specified offset). The slice will
  extend to the end of the target object (or with the specified size). """

  pass

class bytearray(object):
  """ bytearray(iterable_of_ints) -> bytearray.
  bytearray(string, encoding[, errors]) -> bytearray.
  bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.
  bytearray(memory_view) -> bytearray.
  
  Construct an mutable bytearray object from:
    - an iterable yielding integers in range(256)
    - a text string encoded using the specified encoding
    - a bytes or a bytearray object
    - any object implementing the buffer API.
  
  bytearray(int) -> bytearray.
  
  Construct a zero-initialized bytearray of the given length. """

  def __init__(self, iterable_of_ints):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return None

  def append(self, int):
    """ B.append(int) -> None
    
    Append a single item to the end of B. """
    return None

  def capitalize(self):
    """ B.capitalize() -> copy of B
    
    Return a copy of B with only its first character capitalized (ASCII). """
    return None

  def center(self, width, fillchar=None):
    """ B.center(width[, fillchar]) -> copy of B
    
    Return B centered in a string of length width.  Padding is
    done using the specified fill character (default is a space). """
    return None

  def count(self, sub, start=None, end=None):
    """ B.count(sub [,start [,end]]) -> int
    
    Return the number of non-overlapping occurrences of subsection sub in
    bytes B[start:end].  Optional arguments start and end are interpreted
    as in slice notation. """
    return 1

  def decode(self, encoding=None, errors=None):
    """ B.decode([encoding[, errors]]) -> unicode object.
    
    Decodes B using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme.  Default is 'strict' meaning that encoding errors raise
    a UnicodeDecodeError.  Other possible values are 'ignore' and 'replace'
    as well as any other name registered with codecs.register_error that is
    able to handle UnicodeDecodeErrors. """
    return None

  def endswith(self, suffix, start=None, end=None):
    """ B.endswith(suffix [,start [,end]]) -> bool
    
    Return True if B ends with the specified suffix, False otherwise.
    With optional start, test B beginning at that position.
    With optional end, stop comparing B at that position.
    suffix can also be a tuple of strings to try. """
    return None

  def expandtabs(self, tabsize=None):
    """ B.expandtabs([tabsize]) -> copy of B
    
    Return a copy of B where all tab characters are expanded using spaces.
    If tabsize is not given, a tab size of 8 characters is assumed. """
    return None

  def extend(self, arg0):
    """ B.extend(iterable int) -> None
    
    Append all the elements from the iterator or sequence to the
    end of B. """
    return None

  def find(self, sub, start=None, end=None):
    """ B.find(sub [,start [,end]]) -> int
    
    Return the lowest index in B where subsection sub is found,
    such that sub is contained within s[start,end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def fromhex(self, string):
    """ bytearray.fromhex(string) -> bytearray
    
    Create a bytearray object from a string of hexadecimal numbers.
    Spaces between two numbers are accepted.
    Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef'). """
    return None

  def index(self, sub, start=None, end=None):
    """ B.index(sub [,start [,end]]) -> int
    
    Like B.find() but raise ValueError when the subsection is not found. """
    return 1

  def insert(self, index, int):
    """ B.insert(index, int) -> None
    
    Insert a single item into the bytearray before the given index. """
    return None

  def isalnum(self):
    """ B.isalnum() -> bool
    
    Return True if all characters in B are alphanumeric
    and there is at least one character in B, False otherwise. """
    return None

  def isalpha(self):
    """ B.isalpha() -> bool
    
    Return True if all characters in B are alphabetic
    and there is at least one character in B, False otherwise. """
    return None

  def isdigit(self):
    """ B.isdigit() -> bool
    
    Return True if all characters in B are digits
    and there is at least one character in B, False otherwise. """
    return None

  def islower(self):
    """ B.islower() -> bool
    
    Return True if all cased characters in B are lowercase and there is
    at least one cased character in B, False otherwise. """
    return None

  def isspace(self):
    """ B.isspace() -> bool
    
    Return True if all characters in B are whitespace
    and there is at least one character in B, False otherwise. """
    return None

  def istitle(self):
    """ B.istitle() -> bool
    
    Return True if B is a titlecased string and there is at least one
    character in B, i.e. uppercase characters may only follow uncased
    characters and lowercase characters only cased ones. Return False
    otherwise. """
    return None

  def isupper(self):
    """ B.isupper() -> bool
    
    Return True if all cased characters in B are uppercase and there is
    at least one cased character in B, False otherwise. """
    return None

  def join(self, iterable_of_bytes):
    """ B.join(iterable_of_bytes) -> bytes
    
    Concatenates any number of bytearray objects, with B in between each pair. """
    return None

  def ljust(self, width, fillchar=None):
    """ B.ljust(width[, fillchar]) -> copy of B
    
    Return B left justified in a string of length width. Padding is
    done using the specified fill character (default is a space). """
    return None

  def lower(self):
    """ B.lower() -> copy of B
    
    Return a copy of B with all ASCII characters converted to lowercase. """
    return None

  def lstrip(self, bytes=None):
    """ B.lstrip([bytes]) -> bytearray
    
    Strip leading bytes contained in the argument.
    If the argument is omitted, strip leading ASCII whitespace. """
    return None

  def partition(self, sep):
    """ B.partition(sep) -> (head, sep, tail)
    
    Searches for the separator sep in B, and returns the part before it,
    the separator itself, and the part after it.  If the separator is not
    found, returns B and two empty bytearray objects. """
    return (None, None, None)

  def pop(self, index=None):
    """ B.pop([index]) -> int
    
    Remove and return a single item from B. If no index
    argument is given, will pop the last value. """
    return 1

  def remove(self, int):
    """ B.remove(int) -> None
    
    Remove the first occurance of a value in B. """
    return None

  def replace(self, old, new, count=None):
    """ B.replace(old, new[, count]) -> bytes
    
    Return a copy of B with all occurrences of subsection
    old replaced by new.  If the optional argument count is
    given, only the first count occurrences are replaced. """
    return None

  def reverse(self):
    """ B.reverse() -> None
    
    Reverse the order of the values in B in place. """
    return None

  def rfind(self, sub, start=None, end=None):
    """ B.rfind(sub [,start [,end]]) -> int
    
    Return the highest index in B where subsection sub is found,
    such that sub is contained within s[start,end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def rindex(self, sub, start=None, end=None):
    """ B.rindex(sub [,start [,end]]) -> int
    
    Like B.rfind() but raise ValueError when the subsection is not found. """
    return 1

  def rjust(self, width, fillchar=None):
    """ B.rjust(width[, fillchar]) -> copy of B
    
    Return B right justified in a string of length width. Padding is
    done using the specified fill character (default is a space) """
    return None

  def rpartition(self, sep):
    """ B.rpartition(sep) -> (head, sep, tail)
    
    Searches for the separator sep in B, starting at the end of B,
    and returns the part before it, the separator itself, and the
    part after it.  If the separator is not found, returns two empty
    bytearray objects and B. """
    return (None, None, None)

  def rsplit(self, sep, maxsplit=None):
    """ B.rsplit(sep[, maxsplit]) -> list of bytearray
    
    Return a list of the sections in B, using sep as the delimiter,
    starting at the end of B and working to the front.
    If sep is not given, B is split on ASCII whitespace characters
    (space, tab, return, newline, formfeed, vertical tab).
    If maxsplit is given, at most maxsplit splits are done. """
    return []

  def rstrip(self, bytes=None):
    """ B.rstrip([bytes]) -> bytearray
    
    Strip trailing bytes contained in the argument.
    If the argument is omitted, strip trailing ASCII whitespace. """
    return None

  def split(self, sep=None, maxsplit=None):
    """ B.split([sep[, maxsplit]]) -> list of bytearray
    
    Return a list of the sections in B, using sep as the delimiter.
    If sep is not given, B is split on ASCII whitespace characters
    (space, tab, return, newline, formfeed, vertical tab).
    If maxsplit is given, at most maxsplit splits are done. """
    return []

  def splitlines(self, keepends=None):
    """ B.splitlines([keepends]) -> list of lines
    
    Return a list of the lines in B, breaking at line boundaries.
    Line breaks are not included in the resulting list unless keepends
    is given and true. """
    return []

  def startswith(self, prefix, start=None, end=None):
    """ B.startswith(prefix [,start [,end]]) -> bool
    
    Return True if B starts with the specified prefix, False otherwise.
    With optional start, test B beginning at that position.
    With optional end, stop comparing B at that position.
    prefix can also be a tuple of strings to try. """
    return None

  def strip(self, bytes=None):
    """ B.strip([bytes]) -> bytearray
    
    Strip leading and trailing bytes contained in the argument.
    If the argument is omitted, strip ASCII whitespace. """
    return None

  def swapcase(self):
    """ B.swapcase() -> copy of B
    
    Return a copy of B with uppercase ASCII characters converted
    to lowercase ASCII and vice versa. """
    return None

  def title(self):
    """ B.title() -> copy of B
    
    Return a titlecased version of B, i.e. ASCII words start with uppercase
    characters, all remaining cased characters have lowercase. """
    return None

  def translate(self, table, deletechars=None):
    """ B.translate(table[, deletechars]) -> bytearray
    
    Return a copy of B, where all characters occurring in the
    optional argument deletechars are removed, and the remaining
    characters have been mapped through the given translation
    table, which must be a bytes object of length 256. """
    return None

  def upper(self):
    """ B.upper() -> copy of B
    
    Return a copy of B with all ASCII characters converted to uppercase. """
    return None

  def zfill(self, width):
    """ B.zfill(width) -> copy of B
    
    Pad a numeric string B with zeros on the left, to fill a field
    of the specified width.  B is never truncated. """
    return None

bytes = str
def callable(object):
  """ callable(object) -> bool
  
  Return whether the object is callable (i.e., some kind of function).
  Note that classes are callable, as are instances with a __call__() method. """
  return None

def chr(i):
  """ chr(i) -> character
  
  Return a string of one character with ordinal i; 0 <= i < 256. """
  return None

class classmethod(object):
  """ classmethod(function) -> method
  
  Convert a function to be a class method.
  
  A class method receives the class as implicit first argument,
  just like an instance method receives the instance.
  To declare a class method, use this idiom:
  
    class C:
        def f(cls, arg1, arg2, ...): ...
        f = classmethod(f)
  
  It can be called either on the class (e.g. C.f()) or on an instance
  (e.g. C().f()).  The instance is ignored except for its class.
  If a class method is called for a derived class, the derived class
  object is passed as the implied first argument.
  
  Class methods are different than C++ or Java static methods.
  If you want those, see the staticmethod builtin. """

  def __init__(self, function):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return None

def cmp(x, y):
  """ cmp(x, y) -> integer
  
  Return negative if x<y, zero if x==y, positive if x>y. """
  return 1

def coerce(x, y):
  """ coerce(x, y) -> (x1, y1)
  
  Return a tuple consisting of the two numeric arguments converted to
  a common type, using the same rules as used by arithmetic operations.
  If coercion is not possible, raise TypeError. """
  return (None, None)

def compile(source, filename, mode, flags=None, dont_inherit=None):
  """ compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
  
  Compile the source string (a Python module, statement or expression)
  into a code object that can be executed by the exec statement or eval().
  The filename will be used for run-time error messages.
  The mode must be 'exec' to compile a module, 'single' to compile a
  single (interactive) statement, or 'eval' to compile an expression.
  The flags argument, if present, controls which future statements influence
  the compilation of the code.
  The dont_inherit argument, if non-zero, stops the compilation inheriting
  the effects of any future statements in effect in the code calling
  compile; if absent or zero these statements do influence the compilation,
  in addition to any features explicitly specified. """
  return None

class complex(object):
  """ complex(real[, imag]) -> complex number
  
  Create a complex number from a real part and an optional imaginary part.
  This is equivalent to (real + imag*1j) where imag defaults to 0. """

  def conjugate(self):
    """ complex.conjugate() -> complex
    
    Returns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j. """
    return None

  imag = None
  real = None

def copyright():
  """ interactive prompt objects for printing the license text, a list of
      contributors and the copyright notice. """
  pass

def credits():
  """ interactive prompt objects for printing the license text, a list of
      contributors and the copyright notice. """
  pass

def delattr(object, name):
  """ delattr(object, name)
  
  Delete a named attribute on an object; delattr(x, 'y') is equivalent to
  ``del x.y''. """
  pass

class dict(object):
  """ dict() -> new empty dictionary
  dict(mapping) -> new dictionary initialized from a mapping object's
      (key, value) pairs
  dict(iterable) -> new dictionary initialized as if via:
      d = {}
      for k, v in iterable:
          d[k] = v
  dict(**kwargs) -> new dictionary initialized with the name=value pairs
      in the keyword argument list.  For example:  dict(one=1, two=2) """

  def __init__(self):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return {}

  def clear(self):
    """ D.clear() -> None.  Remove all items from D. """
    return None

  def copy(self):
    """ D.copy() -> a shallow copy of D """
    return None

  def fromkeys(self, S, v=None):
    """ dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
    v defaults to None. """
    return {}

  def get(self, k, d=None):
    """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
    return None

  def has_key(self, k):
    """ D.has_key(k) -> True if D has a key k, else False """
    return None

  def items(self):
    """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
    return [()]

  def iteritems(self):
    """ D.iteritems() -> an iterator over the (key, value) items of D """
    return None

  def iterkeys(self):
    """ D.iterkeys() -> an iterator over the keys of D """
    return None

  def itervalues(self):
    """ D.itervalues() -> an iterator over the values of D """
    return None

  def keys(self):
    """ D.keys() -> list of D's keys """
    return []

  def pop(self, k, d=None):
    """ D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
    If key is not found, d is returned if given, otherwise KeyError is raised """
    return None

  def popitem(self):
    """ D.popitem() -> (k, v), remove and return some (key, value) pair as a
    2-tuple; but raise KeyError if D is empty. """
    return None

  def setdefault(self, k, d=None):
    """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
    return None

  def update(self, E, arg0):
    """ D.update(E, **F) -> None.  Update D from dict/iterable E and F.
    If E has a .keys() method, does:     for k in E: D[k] = E[k]
    If E lacks .keys() method, does:     for (k, v) in E: D[k] = v
    In either case, this is followed by: for k in F: D[k] = F[k] """
    return {}

  def values(self):
    """ D.values() -> list of D's values """
    return []

def dir(object=None):
  """ dir([object]) -> list of strings
  
  If called without an argument, return the names in the current scope.
  Else, return an alphabetized list of names comprising (some of) the attributes
  of the given object, and of attributes reachable from it.
  If the object supplies a method named __dir__, it will be used; otherwise
  the default dir() logic is used and returns:
    for a module object: the module's attributes.
    for a class object:  its attributes, and recursively the attributes
      of its bases.
    for any other object: its attributes, its class's attributes, and
      recursively the attributes of its class's base classes. """
  return []

def divmod(x, y):
  """ divmod(x, y) -> (div, mod)
  
  Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x. """
  return (None, None)

class enumerate(object):
  """ enumerate(iterable[, start]) -> iterator for index, value of iterable
  
  Return an enumerate object.  iterable must be another object that supports
  iteration.  The enumerate object yields pairs containing a count (from
  start, which defaults to zero) and a value yielded by the iterable argument.
  enumerate is useful for obtaining an indexed list:
      (0, seq[0]), (1, seq[1]), (2, seq[2]), ... """

  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

def eval(source, globals=None, locals=None):
  """ eval(source[, globals[, locals]]) -> value
  
  Evaluate the source in the context of globals and locals.
  The source may be a string representing a Python expression
  or a code object as returned by compile().
  The globals must be a dictionary and locals can be any mapping,
  defaulting to the current globals and locals.
  If only globals is given, locals defaults to it.
   """
  return None

def execfile(filename, globals=None, locals=None):
  """ execfile(filename[, globals[, locals]])
  
  Read and execute a Python script from a file.
  The globals and locals are dictionaries, defaulting to the current
  globals and locals.  If only globals is given, locals defaults to it. """
  pass

def exit():
  pass

class file(object):
  """ file(name[, mode[, buffering]]) -> file object
  
  Open a file.  The mode can be 'r', 'w' or 'a' for reading (default),
  writing or appending.  The file will be created if it doesn't exist
  when opened for writing or appending; it will be truncated when
  opened for writing.  Add a 'b' to the mode for binary files.
  Add a '+' to the mode to allow simultaneous reading and writing.
  If the buffering argument is given, 0 means unbuffered, 1 means line
  buffered, and larger numbers specify the buffer size.  The preferred way
  to open a file is with the builtin open() function.
  Add a 'U' to mode to open the file for input with universal newline
  support.  Any line ending in the input file will be seen as a '\\n'
  in Python.  Also, a file so opened gains the attribute 'newlines';
  the value for this attribute is one of None (no newline read yet),
  '\\r', '\\n', '\\r\\n' or a tuple containing all the newline types seen.
  
  'U' cannot be combined with 'w' or '+' mode.
   """

  def __init__(self, name, mode=None, buffering=None):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return file(__file__)

  def close(self):
    """ close() -> None or (perhaps) an integer.  Close the file.
    
    Sets data attribute .closed to True.  A closed file cannot be used for
    further I/O operations.  close() may be called more than once without
    error.  Some kinds of file objects (for example, opened by popen())
    may return an exit status upon closing. """
    return file(__file__)

  errors = None

  def fileno(self):
    """ fileno() -> integer "file descriptor".
    
    This is needed for lower-level file interfaces, such os.read(). """
    return file(__file__)

  def flush(self):
    """ flush() -> None.  Flush the internal I/O buffer. """
    return 1

  def isatty(self):
    """ isatty() -> true or false.  True if the file is connected to a tty device. """
    return file(__file__)

  newlines = property(None, None, None,
                      """ end-of-line convention used in this file """
                      )


  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

  def read(self, size=None):
    """ read([size]) -> read at most size bytes, returned as a string.
    
    If the size argument is negative or omitted, read until EOF is reached.
    Notice that when in non-blocking mode, less data than what was requested
    may be returned, even if no size parameter was given. """
    return ""

  def readinto(self):
    """ readinto() -> Undocumented.  Don't use this; it may go away. """
    return None

  def readline(self, size=None):
    """ readline([size]) -> next line from the file, as a string.
    
    Retain newline.  A non-negative size argument limits the maximum
    number of bytes to return (an incomplete line may be returned then).
    Return an empty string at EOF. """
    return ""

  def readlines(self, size=None):
    """ readlines([size]) -> list of strings, each a line from the file.
    
    Call readline() repeatedly and return a list of the lines so read.
    The optional size argument, if given, is an approximate bound on the
    total number of bytes in the lines returned. """
    return []

  def seek(self, offset, whence=None):
    """ seek(offset[, whence]) -> None.  Move to new file position.
    
    Argument offset is a byte count.  Optional argument whence defaults to
    0 (offset from start of file, offset should be >= 0); other values are 1
    (move relative to current position, positive or negative), and 2 (move
    relative to end of file, usually negative, although many platforms allow
    seeking beyond the end of a file).  If the file is opened in text mode,
    only offsets returned by tell() are legal.  Use of other offsets causes
    undefined behavior.
    Note that not all file objects are seekable. """
    return file(__file__)

  def tell(self):
    """ tell() -> current file position, an integer (may be a long integer). """
    return file(__file__)

  def truncate(self, size=None):
    """ truncate([size]) -> None.  Truncate the file to at most size bytes.
    
    Size defaults to the current file position, as returned by tell(). """
    return file(__file__)

  def write(self, str):
    """ write(str) -> None.  Write string str to file.
    
    Note that due to buffering, flush() or close() may be needed before
    the file on disk reflects the data written. """
    return ""

  def writelines(self, sequence_of_strings):
    """ writelines(sequence_of_strings) -> None.  Write the strings to the file.
    
    Note that newlines are not added.  The sequence can be any iterable object
    producing strings. This is equivalent to calling write() for each string. """
    return ""

  def xreadlines(self):
    """ xreadlines() -> returns self.
    
    For backward compatibility. File objects now include the performance
    optimizations previously implemented in the xreadlines module. """
    return None

  # BEGIN MANUAL OVERRIDES FROM static-pi-files/2.6/__builtin__override.py
  closed = 0
  encoding = ''
  mode = ''
  name = ''
  softspace = 0

  # END MANUAL OVERRIDES

class float(object):
  """ float(x) -> floating point number
  
  Convert a string or number to a floating point number, if possible. """

  def as_integer_ratio(self):
    """ float.as_integer_ratio() -> (int, int)
    
    Returns a pair of integers, whose ratio is exactly equal to the original
    float and with a positive denominator.
    Raises OverflowError on infinities and a ValueError on NaNs.
    
    >>> (10.0).as_integer_ratio()
    (10, 1)
    >>> (0.0).as_integer_ratio()
    (0, 1)
    >>> (-.25).as_integer_ratio()
    (-1, 4) """
    return (1, 1)

  def conjugate(self):
    """ Returns self, the complex conjugate of any float. """
    pass

  def fromhex(self, string):
    """ float.fromhex(string) -> float
    
    Create a floating-point number from a hexadecimal string.
    >>> float.fromhex('0x1.ffffp10')
    2047.984375
    >>> float.fromhex('-0x1p-1074')
    -4.9406564584124654e-324 """
    return 1.0

  def hex(self):
    """ float.hex() -> string
    
    Return a hexadecimal representation of a floating-point number.
    >>> (-0.1).hex()
    '-0x1.999999999999ap-4'
    >>> 3.14159.hex()
    '0x1.921f9f01b866ep+1' """
    return ""

  imag = property(None, None, None,
                  """ the imaginary part of a complex number """
                  )


  def is_integer(self):
    """ Returns True if the float is an integer. """
    pass

  real = property(None, None, None,
                  """ the real part of a complex number """
                  )


def format(value, format_spec=None):
  """ format(value[, format_spec]) -> string
  
  Returns value.__format__(format_spec)
  format_spec defaults to "" """
  return ""

class frozenset(object):
  """ frozenset() -> empty frozenset object
  frozenset(iterable) -> frozenset object
  
  Build an immutable unordered collection of unique elements. """

  def copy(self):
    """ Return a shallow copy of a set. """
    pass

  def difference(self, arg0):
    """ Return the difference of two or more sets as a new set.
    
    (i.e. all elements that are in this set but not the others.) """
    pass

  def intersection(self, arg0):
    """ Return the intersection of two or more sets as a new set.
    
    (i.e. elements that are common to all of the sets.) """
    pass

  def isdisjoint(self):
    """ Return True if two sets have a null intersection. """
    pass

  def issubset(self):
    """ Report whether another set contains this set. """
    pass

  def issuperset(self):
    """ Report whether this set contains another set. """
    pass

  def symmetric_difference(self, arg0):
    """ Return the symmetric difference of two sets as a new set.
    
    (i.e. all elements that are in exactly one of the sets.) """
    pass

  def union(self, arg0):
    """ Return the union of sets as a new set.
    
    (i.e. all elements that are in either set.) """
    pass

  # BEGIN MANUAL OVERRIDES FROM static-pi-files/2.6/__builtin__override.py
  def __init__(self, iterable=_NotSpecified):
    pass

  # END MANUAL OVERRIDES

def getattr(object, name, default=None):
  """ getattr(object, name[, default]) -> value
  
  Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
  When a default argument is given, it is returned when the attribute doesn't
  exist; without it, an exception is raised in that case. """
  return None

def globals():
  """ globals() -> dictionary
  
  Return the dictionary containing the current scope's global variables. """
  return {}

def hasattr(object, name):
  """ hasattr(object, name) -> bool
  
  Return whether the object has an attribute with the given name.
  (This is done by calling getattr(object, name) and catching exceptions.) """
  return None

def hash(object):
  """ hash(object) -> integer
  
  Return a hash value for the object.  Two objects with the same value have
  the same hash value.  The reverse is not necessarily true, but likely. """
  return 1

def help(arg0):
  """ Define the built-in 'help'.
      This is a wrapper around pydoc.help (with a twist).
  
       """
  pass

def hex(number):
  """ hex(number) -> string
  
  Return the hexadecimal representation of an integer or long integer. """
  return ""

def id(object):
  """ id(object) -> integer
  
  Return the identity of an object.  This is guaranteed to be unique among
  simultaneously existing objects.  (Hint: it's the object's memory address.) """
  return 1

def input(prompt=None):
  """ input([prompt]) -> value
  
  Equivalent to eval(raw_input(prompt)). """
  return None

class int(object):
  """ int(x[, base]) -> integer
  
  Convert a string or number to an integer, if possible.  A floating point
  argument will be truncated towards zero (this does not include a string
  representation of a floating point number!)  When converting a string, use
  the optional base.  It is an error to supply a base when converting a
  non-string.  If base is zero, the proper base is guessed based on the
  string content.  If the argument is outside the integer range a
  long object will be returned instead. """

  def conjugate(self):
    """ Returns self, the complex conjugate of any int. """
    pass

  denominator = property(None, None, None,
                         """ the denominator of a rational number in lowest terms """
                         )

  imag = property(None, None, None,
                  """ the imaginary part of a complex number """
                  )

  numerator = property(None, None, None,
                       """ the numerator of a rational number in lowest terms """
                       )

  real = property(None, None, None,
                  """ the real part of a complex number """
                  )


def intern(string):
  """ intern(string) -> string
  
  ``Intern'' the given string.  This enters the string in the (global)
  table of interned strings whose purpose is to speed up dictionary lookups.
  Return the string itself or the previously interned string object with the
  same value. """
  return ""

def isinstance(object, class_or_type_or_tuple):
  """ isinstance(object, class-or-type-or-tuple) -> bool
  
  Return whether an object is an instance of a class or of a subclass thereof.
  With a type as second argument, return whether that is the object's type.
  The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
  isinstance(x, A) or isinstance(x, B) or ... (etc.). """
  return None

def issubclass(C, B):
  """ issubclass(C, B) -> bool
  
  Return whether class C is a subclass (i.e., a derived class) of class B.
  When using a tuple as the second argument issubclass(X, (A, B, ...)),
  is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.). """
  return None

def iter(collection):
  """ iter(collection) -> iterator
  iter(callable, sentinel) -> iterator
  
  Get an iterator from an object.  In the first form, the argument must
  supply its own iterator, or be a sequence.
  In the second form, the callable is called until it returns the sentinel. """
  return None

def len(object):
  """ len(object) -> integer
  
  Return the number of items of a sequence or mapping. """
  return 1

def license():
  """ interactive prompt objects for printing the license text, a list of
      contributors and the copyright notice. """
  pass

class list(object):
  """ list() -> new empty list
  list(iterable) -> new list initialized from iterable's items """

  def __init__(self):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return []

  def append(self, object):
    """ L.append(object) -- append object to end """
    return None

  def count(self, value):
    """ L.count(value) -> integer -- return number of occurrences of value """
    return 1

  def extend(self, iterable):
    """ L.extend(iterable) -- extend list by appending elements from the iterable """
    return []

  def index(self, value, start=None, stop=None):
    """ L.index(value, [start, [stop]]) -> integer -- return first index of value.
    Raises ValueError if the value is not present. """
    return 1

  def insert(self, index, object):
    """ L.insert(index, object) -- insert object before index """
    return None

  def pop(self, index=None):
    """ L.pop([index]) -> item -- remove and return item at index (default last).
    Raises IndexError if list is empty or index is out of range. """
    return None

  def remove(self, value):
    """ L.remove(value) -- remove first occurrence of value.
    Raises ValueError if the value is not present. """
    return None

  def reverse(self):
    """ L.reverse() -- reverse *IN PLACE* """
    return None

  def sort(self, cmp=None, key=None, reverse=False):
    """ L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    cmp(x, y) -> -1, 0, 1 """
    return None

def locals():
  """ locals() -> dictionary
  
  Update and return a dictionary containing the current scope's local variables. """
  return {}

class long(object):
  """ long(x[, base]) -> integer
  
  Convert a string or number to a long integer, if possible.  A floating
  point argument will be truncated towards zero (this does not include a
  string representation of a floating point number!)  When converting a
  string, use the optional base.  It is an error to supply a base when
  converting a non-string. """

  def conjugate(self):
    """ Returns self, the complex conjugate of any long. """
    pass

  denominator = property(None, None, None,
                         """ the denominator of a rational number in lowest terms """
                         )

  imag = property(None, None, None,
                  """ the imaginary part of a complex number """
                  )

  numerator = property(None, None, None,
                       """ the numerator of a rational number in lowest terms """
                       )

  real = property(None, None, None,
                  """ the real part of a complex number """
                  )


def map(function, sequence, sequence=None, *args):
  """ map(function, sequence[, sequence, ...]) -> list
  
  Return a list of the results of applying the function to the items of
  the argument sequence(s).  If more than one sequence is given, the
  function is called with an argument list consisting of the corresponding
  item of each sequence, substituting None for missing values when not all
  sequences have the same length.  If the function is None, return a list of
  the items of the sequence (or a list of tuples if more than one sequence). """
  return []

def max(iterable, key=func):
  """ max(iterable[, key=func]) -> value
  max(a, b, c, ...[, key=func]) -> value
  
  With a single iterable argument, return its largest item.
  With two or more arguments, return the largest argument. """
  return None

def min(iterable, key=func):
  """ min(iterable[, key=func]) -> value
  min(a, b, c, ...[, key=func]) -> value
  
  With a single iterable argument, return its smallest item.
  With two or more arguments, return the smallest argument. """
  return None

def next(iterator, default=None):
  """ next(iterator[, default])
  
  Return the next item from the iterator. If default is given and the iterator
  is exhausted, it is returned instead of raising StopIteration. """
  pass

class object:
  """ The most base type """

  def __init__(self, *args):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    pass

def oct(number):
  """ oct(number) -> string
  
  Return the octal representation of an integer or long integer. """
  return ""

def ord(c):
  """ ord(c) -> integer
  
  Return the integer ordinal of a one-character string. """
  return 1

def pow(x, y, z=None):
  """ pow(x, y[, z]) -> number
  
  With two arguments, equivalent to x**y.  With three arguments,
  equivalent to (x**y) % z, but may be more efficient (e.g. for longs). """
  return None

class property(object):
  """ property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
  
  fget is a function to be used for getting an attribute value, and likewise
  fset is a function for setting, and fdel a function for del'ing, an
  attribute.  Typical use is to define a managed attribute x:
  class C(object):
      def getx(self): return self._x
      def setx(self, value): self._x = value
      def delx(self): del self._x
      x = property(getx, setx, delx, "I'm the 'x' property.")
  
  Decorators make defining new properties or modifying existing ones easy:
  class C(object):
      @property
      def x(self): return self._x
      @x.setter
      def x(self, value): self._x = value
      @x.deleter
      def x(self): del self._x
   """

  def __init__(self, fget=None, fset=None, fdel=None, doc=None):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return None

  def deleter(self):
    """ Descriptor to change the deleter on a property. """
    pass

  fdel = None
  fget = None
  fset = None

  def getter(self):
    """ Descriptor to change the getter on a property. """
    pass

  def setter(self):
    """ Descriptor to change the setter on a property. """
    pass

def quit():
  pass

def range(start=None, stop=None, step=None):
  """ range([start,] stop[, step]) -> list of integers
  
  Return a list containing an arithmetic progression of integers.
  range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
  When step is given, it specifies the increment (or decrement).
  For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
  These are exactly the valid indices for a list of 4 elements. """
  return []

def raw_input(prompt=None):
  """ raw_input([prompt]) -> string
  
  Read a string from standard input.  The trailing newline is stripped.
  If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
  On Unix, GNU readline is used if enabled.  The prompt string, if given,
  is printed without a trailing newline before reading. """
  return ""

def reduce(function, sequence, initial=None):
  """ reduce(function, sequence[, initial]) -> value
  
  Apply a function of two arguments cumulatively to the items of a sequence,
  from left to right, so as to reduce the sequence to a single value.
  For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
  ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
  of the sequence in the calculation, and serves as a default when the
  sequence is empty. """
  return None

def reload(module):
  """ reload(module) -> module
  
  Reload the module.  The module must have been successfully imported before. """
  return None

def repr(object):
  """ repr(object) -> string
  
  Return the canonical string representation of the object.
  For most object types, eval(repr(object)) == object. """
  return ""

class reversed(object):
  """ reversed(sequence) -> reverse iterator over values of the sequence
  
  Return a reverse iterator """

  def next(self):
    """ x.next() -> the next value, or raise StopIteration """
    return None

def round(number, ndigits=None):
  """ round(number[, ndigits]) -> floating point number
  
  Round a number to a given precision in decimal digits (default 0 digits).
  This always returns a floating point number.  Precision may be negative. """
  return 1

class set(object):
  """ set() -> new empty set object
  set(iterable) -> new set object
  
  Build an unordered collection of unique elements. """

  def add(self):
    """ Add an element to a set.
    
    This has no effect if the element is already present. """
    pass

  def clear(self):
    """ Remove all elements from this set. """
    pass

  def copy(self):
    """ Return a shallow copy of a set. """
    pass

  def difference(self, arg0):
    """ Return the difference of two or more sets as a new set.
    
    (i.e. all elements that are in this set but not the others.) """
    pass

  def difference_update(self):
    """ Remove all elements of another set from this set. """
    pass

  def discard(self):
    """ Remove an element from a set if it is a member.
    
    If the element is not a member, do nothing. """
    pass

  def intersection(self, arg0):
    """ Return the intersection of two or more sets as a new set.
    
    (i.e. elements that are common to all of the sets.) """
    pass

  def intersection_update(self):
    """ Update a set with the intersection of itself and another. """
    pass

  def isdisjoint(self):
    """ Return True if two sets have a null intersection. """
    pass

  def issubset(self):
    """ Report whether another set contains this set. """
    pass

  def issuperset(self):
    """ Report whether this set contains another set. """
    pass

  def pop(self):
    """ Remove and return an arbitrary set element.
    Raises KeyError if the set is empty. """
    pass

  def remove(self):
    """ Remove an element from a set; it must be a member.
    
    If the element is not a member, raise a KeyError. """
    pass

  def symmetric_difference(self, arg0):
    """ Return the symmetric difference of two sets as a new set.
    
    (i.e. all elements that are in exactly one of the sets.) """
    pass

  def symmetric_difference_update(self):
    """ Update a set with the symmetric difference of itself and another. """
    pass

  def union(self, arg0):
    """ Return the union of sets as a new set.
    
    (i.e. all elements that are in either set.) """
    pass

  def update(self):
    """ Update a set with the union of itself and others. """
    pass

  # BEGIN MANUAL OVERRIDES FROM static-pi-files/2.6/__builtin__override.py
  def __init__(self, iterable=_NotSpecified):
    pass

  # END MANUAL OVERRIDES

def setattr(object, name, value):
  """ setattr(object, name, value)
  
  Set a named attribute on an object; setattr(x, 'y', v) is equivalent to
  ``x.y = v''. """
  pass

class slice(object):
  """ slice([start,] stop[, step])
  
  Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]). """

  def indices(self, len):
    """ S.indices(len) -> (start, stop, stride)
    
    Assuming a sequence of length len, calculate the start and stop
    indices, and the stride length of the extended slice described by
    S. Out of bounds indices are clipped in a manner consistent with the
    handling of normal slices. """
    return (None, None, "")

  start = None
  step = None
  stop = None

def sorted(iterable, cmp=None, key=None, reverse=False):
  """ sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list """
  return []

class staticmethod(object):
  """ staticmethod(function) -> method
  
  Convert a function to be a static method.
  
  A static method does not receive an implicit first argument.
  To declare a static method, use this idiom:
  
       class C:
       def f(arg1, arg2, ...): ...
       f = staticmethod(f)
  
  It can be called either on the class (e.g. C.f()) or on an instance
  (e.g. C().f()).  The instance is ignored except for its class.
  
  Static methods in Python are similar to those found in Java or C++.
  For a more advanced concept, see the classmethod builtin. """

  def __init__(self, function):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return None

class str(basestring):
  """ str(object) -> string
  
  Return a nice string representation of the object.
  If the argument is a string, the return value is the same object. """

  def _formatter_field_name_split(self):
    pass

  def _formatter_parser(self):
    pass

  def capitalize(self):
    """ S.capitalize() -> string
    
    Return a copy of the string S with only its first character
    capitalized. """
    return ""

  def center(self, width, fillchar=None):
    """ S.center(width[, fillchar]) -> string
    
    Return S centered in a string of length width. Padding is
    done using the specified fill character (default is a space) """
    return ""

  def count(self, sub, start=None, end=None):
    """ S.count(sub[, start[, end]]) -> int
    
    Return the number of non-overlapping occurrences of substring sub in
    string S[start:end].  Optional arguments start and end are interpreted
    as in slice notation. """
    return 1

  def decode(self, encoding=None, errors=None):
    """ S.decode([encoding[,errors]]) -> object
    
    Decodes S using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
    as well as any other name registered with codecs.register_error that is
    able to handle UnicodeDecodeErrors. """
    return None

  def encode(self, encoding=None, errors=None):
    """ S.encode([encoding[,errors]]) -> object
    
    Encodes S using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
    'xmlcharrefreplace' as well as any other name registered with
    codecs.register_error that is able to handle UnicodeEncodeErrors. """
    return None

  def endswith(self, suffix, start=None, end=None):
    """ S.endswith(suffix[, start[, end]]) -> bool
    
    Return True if S ends with the specified suffix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    suffix can also be a tuple of strings to try. """
    return None

  def expandtabs(self, tabsize=None):
    """ S.expandtabs([tabsize]) -> string
    
    Return a copy of S where all tab characters are expanded using spaces.
    If tabsize is not given, a tab size of 8 characters is assumed. """
    return ""

  def find(self, sub, start=None, end=None):
    """ S.find(sub [,start [,end]]) -> int
    
    Return the lowest index in S where substring sub is found,
    such that sub is contained within s[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def format(self, arg0, arg1):
    """ S.format(*args, **kwargs) -> string
    
     """
    return ""

  def index(self, sub, start=None, end=None):
    """ S.index(sub [,start [,end]]) -> int
    
    Like S.find() but raise ValueError when the substring is not found. """
    return 1

  def isalnum(self):
    """ S.isalnum() -> bool
    
    Return True if all characters in S are alphanumeric
    and there is at least one character in S, False otherwise. """
    return None

  def isalpha(self):
    """ S.isalpha() -> bool
    
    Return True if all characters in S are alphabetic
    and there is at least one character in S, False otherwise. """
    return None

  def isdigit(self):
    """ S.isdigit() -> bool
    
    Return True if all characters in S are digits
    and there is at least one character in S, False otherwise. """
    return None

  def islower(self):
    """ S.islower() -> bool
    
    Return True if all cased characters in S are lowercase and there is
    at least one cased character in S, False otherwise. """
    return None

  def isspace(self):
    """ S.isspace() -> bool
    
    Return True if all characters in S are whitespace
    and there is at least one character in S, False otherwise. """
    return None

  def istitle(self):
    """ S.istitle() -> bool
    
    Return True if S is a titlecased string and there is at least one
    character in S, i.e. uppercase characters may only follow uncased
    characters and lowercase characters only cased ones. Return False
    otherwise. """
    return None

  def isupper(self):
    """ S.isupper() -> bool
    
    Return True if all cased characters in S are uppercase and there is
    at least one cased character in S, False otherwise. """
    return None

  def join(self, iterable):
    """ S.join(iterable) -> string
    
    Return a string which is the concatenation of the strings in the
    iterable.  The separator between elements is S. """
    return ""

  def ljust(self, width, fillchar=None):
    """ S.ljust(width[, fillchar]) -> string
    
    Return S left-justified in a string of length width. Padding is
    done using the specified fill character (default is a space). """
    return ""

  def lower(self):
    """ S.lower() -> string
    
    Return a copy of the string S converted to lowercase. """
    return ""

  def lstrip(self, chars=None):
    """ S.lstrip([chars]) -> string or unicode
    
    Return a copy of the string S with leading whitespace removed.
    If chars is given and not None, remove characters in chars instead.
    If chars is unicode, S will be converted to unicode before stripping """
    return ""

  def partition(self, sep):
    """ S.partition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, and return the part before it,
    the separator itself, and the part after it.  If the separator is not
    found, return S and two empty strings. """
    return (None, None, None)

  def replace(self, old, new, count=None):
    """ S.replace(old, new[, count]) -> string
    
    Return a copy of string S with all occurrences of substring
    old replaced by new.  If the optional argument count is
    given, only the first count occurrences are replaced. """
    return ""

  def rfind(self, sub, start=None, end=None):
    """ S.rfind(sub [,start [,end]]) -> int
    
    Return the highest index in S where substring sub is found,
    such that sub is contained within s[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def rindex(self, sub, start=None, end=None):
    """ S.rindex(sub [,start [,end]]) -> int
    
    Like S.rfind() but raise ValueError when the substring is not found. """
    return 1

  def rjust(self, width, fillchar=None):
    """ S.rjust(width[, fillchar]) -> string
    
    Return S right-justified in a string of length width. Padding is
    done using the specified fill character (default is a space) """
    return ""

  def rpartition(self, sep):
    """ S.rpartition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, starting at the end of S, and return
    the part before it, the separator itself, and the part after it.  If the
    separator is not found, return two empty strings and S. """
    return (None, None, None)

  def rsplit(self, sep=None, maxsplit=None):
    """ S.rsplit([sep [,maxsplit]]) -> list of strings
    
    Return a list of the words in the string S, using sep as the
    delimiter string, starting at the end of the string and working
    to the front.  If maxsplit is given, at most maxsplit splits are
    done. If sep is not specified or is None, any whitespace string
    is a separator. """
    return []

  def rstrip(self, chars=None):
    """ S.rstrip([chars]) -> string or unicode
    
    Return a copy of the string S with trailing whitespace removed.
    If chars is given and not None, remove characters in chars instead.
    If chars is unicode, S will be converted to unicode before stripping """
    return ""

  def split(self, sep=None, maxsplit=None):
    """ S.split([sep [,maxsplit]]) -> list of strings
    
    Return a list of the words in the string S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are removed
    from the result. """
    return []

  def splitlines(self, keepends=None):
    """ S.splitlines([keepends]) -> list of strings
    
    Return a list of the lines in S, breaking at line boundaries.
    Line breaks are not included in the resulting list unless keepends
    is given and true. """
    return []

  def startswith(self, prefix, start=None, end=None):
    """ S.startswith(prefix[, start[, end]]) -> bool
    
    Return True if S starts with the specified prefix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    prefix can also be a tuple of strings to try. """
    return None

  def strip(self, chars=None):
    """ S.strip([chars]) -> string or unicode
    
    Return a copy of the string S with leading and trailing
    whitespace removed.
    If chars is given and not None, remove characters in chars instead.
    If chars is unicode, S will be converted to unicode before stripping """
    return ""

  def swapcase(self):
    """ S.swapcase() -> string
    
    Return a copy of the string S with uppercase characters
    converted to lowercase and vice versa. """
    return ""

  def title(self):
    """ S.title() -> string
    
    Return a titlecased version of S, i.e. words start with uppercase
    characters, all remaining cased characters have lowercase. """
    return ""

  def translate(self, table, deletechars=None):
    """ S.translate(table [,deletechars]) -> string
    
    Return a copy of the string S, where all characters occurring
    in the optional argument deletechars are removed, and the
    remaining characters have been mapped through the given
    translation table, which must be a string of length 256. """
    return ""

  def upper(self):
    """ S.upper() -> string
    
    Return a copy of the string S converted to uppercase. """
    return ""

  def zfill(self, width):
    """ S.zfill(width) -> string
    
    Pad a numeric string S with zeros on the left, to fill a field
    of the specified width.  The string S is never truncated. """
    return ""

def sum(sequence, start=None):
  """ sum(sequence[, start]) -> value
  
  Returns the sum of a sequence of numbers (NOT strings) plus the value
  of parameter 'start' (which defaults to 0).  When the sequence is
  empty, returns start. """
  return None

class tuple(object):
  """ tuple() -> empty tuple
  tuple(iterable) -> tuple initialized from iterable's items
  
  If the argument is a tuple, the return value is the same object. """

  def count(self, value):
    """ T.count(value) -> integer -- return number of occurrences of value """
    return 1

  def index(self, value, start=None, stop=None):
    """ T.index(value, [start, [stop]]) -> integer -- return first index of value.
    Raises ValueError if the value is not present. """
    return 1

class type(object):
  """ type(object) -> the object's type
  type(name, bases, dict) -> a new type """

  def __init__(self, object):
    """ x.__init__(...) initializes x; see x.__class__.__doc__ for signature """
    return None

  def mro(self):
    """ mro() -> list
    return a type's method resolution order """
    return []

def unichr(i):
  """ unichr(i) -> Unicode character
  
  Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. """
  return None

class unicode(basestring):
  """ unicode(string [, encoding[, errors]]) -> object
  
  Create a new Unicode object from the given encoded string.
  encoding defaults to the current default string encoding.
  errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'. """

  def _formatter_field_name_split(self):
    pass

  def _formatter_parser(self):
    pass

  def capitalize(self):
    """ S.capitalize() -> unicode
    
    Return a capitalized version of S, i.e. make the first character
    have upper case. """
    return None

  def center(self, width, fillchar=None):
    """ S.center(width[, fillchar]) -> unicode
    
    Return S centered in a Unicode string of length width. Padding is
    done using the specified fill character (default is a space) """
    return None

  def count(self, sub, start=None, end=None):
    """ S.count(sub[, start[, end]]) -> int
    
    Return the number of non-overlapping occurrences of substring sub in
    Unicode string S[start:end].  Optional arguments start and end are
    interpreted as in slice notation. """
    return 1

  def decode(self, encoding=None, errors=None):
    """ S.decode([encoding[,errors]]) -> string or unicode
    
    Decodes S using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
    as well as any other name registerd with codecs.register_error that is
    able to handle UnicodeDecodeErrors. """
    return ""

  def encode(self, encoding=None, errors=None):
    """ S.encode([encoding[,errors]]) -> string or unicode
    
    Encodes S using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
    'xmlcharrefreplace' as well as any other name registered with
    codecs.register_error that can handle UnicodeEncodeErrors. """
    return ""

  def endswith(self, suffix, start=None, end=None):
    """ S.endswith(suffix[, start[, end]]) -> bool
    
    Return True if S ends with the specified suffix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    suffix can also be a tuple of strings to try. """
    return None

  def expandtabs(self, tabsize=None):
    """ S.expandtabs([tabsize]) -> unicode
    
    Return a copy of S where all tab characters are expanded using spaces.
    If tabsize is not given, a tab size of 8 characters is assumed. """
    return None

  def find(self, sub, start=None, end=None):
    """ S.find(sub [,start [,end]]) -> int
    
    Return the lowest index in S where substring sub is found,
    such that sub is contained within s[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def format(self, arg0, arg1):
    """ S.format(*args, **kwargs) -> unicode
    
     """
    return None

  def index(self, sub, start=None, end=None):
    """ S.index(sub [,start [,end]]) -> int
    
    Like S.find() but raise ValueError when the substring is not found. """
    return 1

  def isalnum(self):
    """ S.isalnum() -> bool
    
    Return True if all characters in S are alphanumeric
    and there is at least one character in S, False otherwise. """
    return None

  def isalpha(self):
    """ S.isalpha() -> bool
    
    Return True if all characters in S are alphabetic
    and there is at least one character in S, False otherwise. """
    return None

  def isdecimal(self):
    """ S.isdecimal() -> bool
    
    Return True if there are only decimal characters in S,
    False otherwise. """
    return None

  def isdigit(self):
    """ S.isdigit() -> bool
    
    Return True if all characters in S are digits
    and there is at least one character in S, False otherwise. """
    return None

  def islower(self):
    """ S.islower() -> bool
    
    Return True if all cased characters in S are lowercase and there is
    at least one cased character in S, False otherwise. """
    return None

  def isnumeric(self):
    """ S.isnumeric() -> bool
    
    Return True if there are only numeric characters in S,
    False otherwise. """
    return None

  def isspace(self):
    """ S.isspace() -> bool
    
    Return True if all characters in S are whitespace
    and there is at least one character in S, False otherwise. """
    return None

  def istitle(self):
    """ S.istitle() -> bool
    
    Return True if S is a titlecased string and there is at least one
    character in S, i.e. upper- and titlecase characters may only
    follow uncased characters and lowercase characters only cased ones.
    Return False otherwise. """
    return None

  def isupper(self):
    """ S.isupper() -> bool
    
    Return True if all cased characters in S are uppercase and there is
    at least one cased character in S, False otherwise. """
    return None

  def join(self, iterable):
    """ S.join(iterable) -> unicode
    
    Return a string which is the concatenation of the strings in the
    iterable.  The separator between elements is S. """
    return None

  def ljust(self, width, fillchar=None):
    """ S.ljust(width[, fillchar]) -> int
    
    Return S left-justified in a Unicode string of length width. Padding is
    done using the specified fill character (default is a space). """
    return 1

  def lower(self):
    """ S.lower() -> unicode
    
    Return a copy of the string S converted to lowercase. """
    return None

  def lstrip(self, chars=None):
    """ S.lstrip([chars]) -> unicode
    
    Return a copy of the string S with leading whitespace removed.
    If chars is given and not None, remove characters in chars instead.
    If chars is a str, it will be converted to unicode before stripping """
    return None

  def partition(self, sep):
    """ S.partition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, and return the part before it,
    the separator itself, and the part after it.  If the separator is not
    found, return S and two empty strings. """
    return (None, None, None)

  def replace(self, old, new, count=None):
    """ S.replace(old, new[, count]) -> unicode
    
    Return a copy of S with all occurrences of substring
    old replaced by new.  If the optional argument count is
    given, only the first count occurrences are replaced. """
    return None

  def rfind(self, sub, start=None, end=None):
    """ S.rfind(sub [,start [,end]]) -> int
    
    Return the highest index in S where substring sub is found,
    such that sub is contained within s[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def rindex(self, sub, start=None, end=None):
    """ S.rindex(sub [,start [,end]]) -> int
    
    Like S.rfind() but raise ValueError when the substring is not found. """
    return 1

  def rjust(self, width, fillchar=None):
    """ S.rjust(width[, fillchar]) -> unicode
    
    Return S right-justified in a Unicode string of length width. Padding is
    done using the specified fill character (default is a space). """
    return None

  def rpartition(self, sep):
    """ S.rpartition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, starting at the end of S, and return
    the part before it, the separator itself, and the part after it.  If the
    separator is not found, return two empty strings and S. """
    return (None, None, None)

  def rsplit(self, sep=None, maxsplit=None):
    """ S.rsplit([sep [,maxsplit]]) -> list of strings
    
    Return a list of the words in S, using sep as the
    delimiter string, starting at the end of the string and
    working to the front.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified, any whitespace string
    is a separator. """
    return []

  def rstrip(self, chars=None):
    """ S.rstrip([chars]) -> unicode
    
    Return a copy of the string S with trailing whitespace removed.
    If chars is given and not None, remove characters in chars instead.
    If chars is a str, it will be converted to unicode before stripping """
    return None

  def split(self, sep=None, maxsplit=None):
    """ S.split([sep [,maxsplit]]) -> list of strings
    
    Return a list of the words in S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are
    removed from the result. """
    return []

  def splitlines(self, keepends=None):
    """ S.splitlines([keepends]) -> list of strings
    
    Return a list of the lines in S, breaking at line boundaries.
    Line breaks are not included in the resulting list unless keepends
    is given and true. """
    return []

  def startswith(self, prefix, start=None, end=None):
    """ S.startswith(prefix[, start[, end]]) -> bool
    
    Return True if S starts with the specified prefix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    prefix can also be a tuple of strings to try. """
    return None

  def strip(self, chars=None):
    """ S.strip([chars]) -> unicode
    
    Return a copy of the string S with leading and trailing
    whitespace removed.
    If chars is given and not None, remove characters in chars instead.
    If chars is a str, it will be converted to unicode before stripping """
    return None

  def swapcase(self):
    """ S.swapcase() -> unicode
    
    Return a copy of S with uppercase characters converted to lowercase
    and vice versa. """
    return None

  def title(self):
    """ S.title() -> unicode
    
    Return a titlecased version of S, i.e. words start with title case
    characters, all remaining cased characters have lower case. """
    return None

  def translate(self, table):
    """ S.translate(table) -> unicode
    
    Return a copy of the string S, where all characters have been mapped
    through the given translation table, which must be a mapping of
    Unicode ordinals to Unicode ordinals, Unicode strings or None.
    Unmapped characters are left untouched. Characters mapped to None
    are deleted. """
    return None

  def upper(self):
    """ S.upper() -> unicode
    
    Return a copy of S converted to uppercase. """
    return None

  def zfill(self, width):
    """ S.zfill(width) -> unicode
    
    Pad a numeric string S with zeros on the left, to fill a field
    of the specified width. The string S is never truncated. """
    return None

def vars(object=None):
  """ vars([object]) -> dictionary
  
  Without arguments, equivalent to locals().
  With an argument, equivalent to object.__dict__. """
  return {}

class xrange(object):
  """ xrange([start,] stop[, step]) -> xrange object
  
  Like range(), but instead of returning a list, returns an object that
  generates the numbers in the range on demand.  For looping, this is 
  slightly faster than range() and more memory efficient. """

  pass

def zip(seq1, arg0=None):
  """ zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
  
  Return a list of tuples, where each tuple contains the i-th element
  from each of the argument sequences.  The returned list is truncated
  in length to the length of the shortest argument sequence. """
  return []

# BEGIN MANUAL OVERRIDES FROM static-pi-files/2.6/__builtin__override.py
__builtins__ = {}
__doc__ = None
__file__ = '/home/shared/src/ide/build-files/static-pi-files/2.6/__builtin__override.py'
def __import__(name, globals, locals, fromlist): # -> module
  """ __import__(name, globals, locals, fromlist) -> module
  Import a module. The globals are only used to determine the
  context; they are not modified. T he locals are currently unused. The
  fromlist should be a list of names to em ulate ``from name import ...'', or
  an empty list to emulate ``import name''. When importing a module from
  a package, note that __import__('A.B', ...) returns package A when
  fromlist is empty, but its submodule B when fromlist is not empty."""
  
  return module

__name__ = '__builtin__override'
__package__ = None
def filter(function_or_None, sequence):
  """ filter(function or None, sequence) -> list, tuple, or string
  
  Return those items of sequence for which function(item) is true.  If
  function is None, return the items that are true.  If sequence is a tuple
  or string, return the same type, else return a list. """
  return ()

def open(name, mode = 'r', buffering = 1): # -> file object
  """ open(name, mode='r', buffering=1) -> file object
  Open a file.  The mode can be 'r', 'w' or 'a' for reading (default),
  writing or appending.  The file will be created if it doesn't exist
  when opened for writing or appending; it will be truncated when
  opened for writing.  Add a 'b' to the mode for binary files.
  Add a '+' to the mode to allow simultaneous reading and writing.
  If the buffering argument is given, 0 means unbuffered, 1 means line
  buffered, and larger numbers specify the buffer size.
  Note:  open() is an alias for file(). """

  return file(name, mode, buffering)

def super(type, obj=None):
  """super(type) -> unbound super object
  super(type, obj) -> bound super object; requires isinstance(obj, type)
  super(type, type2) -> bound super object; requires issubclass(type2, type)
  Typical use to call a cooperative superclass method:
  class C(B):
  def meth(self, arg):
    super(C, self).meth(arg)"""
  
  return object()

# END MANUAL OVERRIDES