def Func(arg_0):
        """
        Returns a zero-based column number of the beginning of this range.
        """
        arg_1, Func = arg_0.source_buffer.decompose_position(arg_0.begin_pos)
        return Func


def Func(arg_0):
        """
        Returns the line number of the beginning of this range.
        """
        Func, arg_2 = arg_0.source_buffer.decompose_position(arg_0.begin_pos)
        return Func


def Func(arg_0):
        """
        Returns the lines of source code containing the entirety of this range.
        """
        return [arg_0.source_buffer.source_line(arg_1)
                for arg_1 in range(arg_0.line(), arg_0.end().line() + 1)]


def Func(arg_0, arg_1, arg_2=False):
    """
    An AST comparison function. Returns ``True`` if all fields in
    ``left`` are equal to fields in ``right``; if ``Func_locs`` is
    true, all locations should match as well.
    """
    if type(arg_0) != type(arg_1):
        return False

    if isinstance(arg_0, ast.AST):
        for arg_3 in arg_0._fields:
            if not Func(getattr(arg_0, arg_3), getattr(arg_1, arg_3)):
                return False

        if arg_2:
            for arg_4 in arg_0._locs:
                if getattr(arg_0, arg_4) != getattr(arg_1, arg_4):
                    return False

        return True
    elif isinstance(arg_0, list):
        if len(arg_0) != len(arg_1):
            return False

        for arg_5, arg_6 in zip(arg_0, arg_1):
            if not Func(arg_5, arg_6):
                return False

        return True
    else:
        return arg_0 == arg_1


def Func(arg_0, arg_1, arg_2):
  """Convert a 32-bit or 64-bit integer created
  by float_pack into a Python float."""

  if arg_1 == 8:
    arg_3 = -1021  # = sys.float_info.min_exp
    arg_4 = 1024   # = sys.float_info.max_exp
    arg_5 = 53    # = sys.float_info.mant_dig
    arg_6 = 64
  elif arg_1 == 4:
    arg_3 = -125   # C's FLT_MIN_EXP
    arg_4 = 128    # FLT_MAX_EXP
    arg_5 = 24    # FLT_MANT_DIG
    arg_6 = 32
  else:
    raise ValueError("invalid size value")

  if arg_0 >> arg_6:
    raise ValueError("input out of range")

  # extract pieces
  arg_7 = arg_0 >> arg_6 - 1
  arg_8 = (arg_0 & ((1 << arg_6 - 1) - (1 << arg_5 - 1))) >> arg_5 - 1
  arg_9 = arg_0 & ((1 << arg_5 - 1) - 1)

  if arg_8 == arg_4 - arg_3 + 2:
    # nan or infinity
    arg_10 = float('nan') if arg_9 else float('inf')
  elif arg_8 == 0:
    # subnormal or zero
    arg_10 = math.ldexp(float(arg_9), arg_3 - arg_5)
  else:
    # normal
    arg_9 += 1 << arg_5 - 1
    arg_10 = math.ldexp(float(arg_9), arg_8 + arg_3 - arg_5 - 1)
  return -arg_10 if arg_7 else arg_10


def Func(arg_0, arg_1):
  """Convert a Python float x into a 64-bit unsigned integer
  with the same byte representation."""

  if arg_1 == 8:
    arg_2 = -1021  # = sys.float_info.min_exp
    arg_3 = 1024   # = sys.float_info.max_exp
    arg_4 = 53    # = sys.float_info.mant_dig
    arg_5 = 64
  elif arg_1 == 4:
    arg_2 = -125   # C's FLT_MIN_EXP
    arg_3 = 128    # FLT_MAX_EXP
    arg_4 = 24    # FLT_MANT_DIG
    arg_5 = 32
  else:
    raise ValueError("invalid size value")

  arg_6 = math.copysign(1.0, arg_0) < 0.0
  if math.isinf(arg_0):
    arg_7 = 0
    arg_8 = arg_3 - arg_2 + 2
  elif math.isnan(arg_0):
    arg_7 = 1 << (arg_4 - 2)  # other values possible
    arg_8 = arg_3 - arg_2 + 2
  elif arg_0 == 0.0:
    arg_7 = 0
    arg_8 = 0
  else:
    arg_9, arg_10 = math.frexp(abs(arg_0))  # abs(x) == m * 2**e
    arg_8 = arg_10 - (arg_2 - 1)
    if arg_8 > 0:
      # Normal case.
      arg_7 = round_to_nearest(arg_9 * (1 << arg_4))
      arg_7 -= 1 << arg_4 - 1
    else:
      # Subnormal case.
      if arg_8 + arg_4 - 1 >= 0:
        arg_7 = round_to_nearest(arg_9 * (1 << arg_8 + arg_4 - 1))
      else:
        arg_7 = 0
      arg_8 = 0

    # Special case: rounding produced a MANT_DIG-bit mantissa.
    assert 0 <= arg_7 <= 1 << arg_4 - 1
    if arg_7 == 1 << arg_4 - 1:
      arg_7 = 0
      arg_8 += 1

    # Raise on overflow (in some circumstances, may want to return
    # infinity instead).
    if arg_8 >= arg_3 - arg_2 + 2:
      raise OverflowError("float too large to pack in this format")

  # check constraints
  assert 0 <= arg_7 < 1 << arg_4 - 1
  assert 0 <= arg_8 <= arg_3 - arg_2 + 2
  assert 0 <= arg_6 <= 1
  return ((arg_6 << arg_5 - 1) | (arg_8 << arg_4 - 1)) | arg_7


def Func(arg_0, *arg_1):
        """
        A Func manager that appends ``note`` to every diagnostic processed by
        this engine.
        """
        arg_0._appended_notes += arg_1
        yield
        del arg_0._appended_notes[-len(arg_1):]


def Func(arg_0):
    """Format a list of traceback entry tuples for printing.

    Given a list of tuples as returned by extract_tb() or
    extract_stack(), return a list of strings ready for printing.
    Each string in the resulting list corresponds to the item with the
    same index in the argument list.  Each string ends in a newline;
    the strings may contain internal newlines as well, for those items
    whose source text line is not None.
    """
    arg_1 = []
    for arg_2, arg_3, arg_4, arg_5 in arg_0:
        arg_6 = '  File "%s", line %d, in %s\n' % (arg_2,arg_3,arg_4)
        if arg_5:
            arg_6 = arg_6 + '    %s\n' % arg_5.strip()
        arg_1.append(arg_6)
    return arg_1


def Func(arg_0, arg_1=None, arg_2=None):
    """Print up to 'limit' stack trace entries from the traceback 'tb'.

    If 'limit' is omitted or None, all entries are printed.  If 'file'
    is omitted or None, the output goes to sys.stderr; otherwise
    'file' should be an open file or file-like object with a write()
    method.
    """
    if arg_2 is None:
        arg_2 = sys.stderr
    if arg_1 is None:
        if hasattr(sys, 'tracebacklimit'):
            arg_1 = sys.tracebacklimit
    arg_3 = 0
    while arg_0 is not None and (arg_1 is None or arg_3 < arg_1):
        arg_4 = arg_0.tb_frame
        arg_5 = arg_0.tb_lineno
        arg_6 = arg_4.f_code
        arg_7 = arg_6.co_filename
        arg_8 = arg_6.co_name
        _print(arg_2,
               '  File "%s", line %d, in %s' % (arg_7, arg_5, arg_8))
        linecache.checkcache(arg_7)
        arg_9 = linecache.getline(arg_7, arg_5, arg_4.f_globals)
        if arg_9: _print(arg_2, '    ' + arg_9.strip())
        arg_0 = arg_0.tb_next
        arg_3 = arg_3+1


def Func(arg_0, arg_1, arg_2, arg_3=None, arg_4=None):
    """Print exception up to 'limit' stack trace entries from 'tb' to 'file'.

    This differs from print_tb() in the following ways: (1) if
    traceback is not None, it prints a header "Traceback (most recent
    call last):"; (2) it prints the exception type and value after the
    stack trace; (3) if type is SyntaxError and value has the
    appropriate format, it prints the line where the syntax error
    occurred with a caret on the next line indicating the approximate
    position of the error.
    """
    if arg_4 is None:
        # TODO: Use sys.stderr when that's implemented.
        arg_4 = open('/dev/stderr', 'w')
        #file = sys.stderr
    if arg_2:
        _print(arg_4, 'Traceback (most recent call last):')
        print_tb(arg_2, arg_3, arg_4)
    arg_5 = format_exception_only(arg_0, arg_1)
    for arg_6 in arg_5:
        _print(arg_4, arg_6, '')


def Func(arg_0, arg_1, arg_2, arg_3 = None):
    """Format a stack trace and the exception information.

    The arguments have the same meaning as the corresponding arguments
    to print_exception().  The return value is a list of strings, each
    ending in a newline and some containing internal newlines.  When
    these lines are concatenated and printed, exactly the same text is
    printed as does print_exception().
    """
    if arg_2:
        arg_4 = ['Traceback (most recent call last):\n']
        arg_4 = arg_4 + format_tb(arg_2, arg_3)
    else:
        arg_4 = []
    arg_4 = arg_4 + Func_only(arg_0, arg_1)
    return arg_4


def Func(arg_0, arg_1, arg_2=None):
        """x, random=random.random -> Func list x in place; return None.

        Optional arg random is a 0-argument function returning a random
        float in [0.0, 1.0); by default, the standard random.random.

        """

        if arg_2 is None:
            arg_2 = arg_0.random
        arg_3 = int
        for arg_4 in reversed(xrange(1, len(arg_1))):
            # pick an element in x[:i+1] with which to exchange x[i]
            arg_5 = arg_3(arg_2() * (arg_4+1))
            arg_1[arg_4], arg_1[arg_5] = arg_1[arg_5], arg_1[arg_4]


def Func(arg_0):
    """Return a list of slot names for a given class.

    This needs to find slots defined by the class and its bases, so we
    can't simply return the __slots__ attribute.  We must walk down
    the Method Resolution Order and concatenate the __slots__ of each
    class found there.  (This assumes classes don't modify their
    __slots__ attribute to misrepresent their slots after the class is
    defined.)
    """

    # Get the value from a cache in the class if possible
    arg_1 = arg_0.__dict__.get("_Func__")
    if arg_1 is not None:
        return arg_1

    # Not cached -- calculate the value
    arg_1 = []
    if not hasattr(arg_0, "__slots__"):
        # This class has no slots
        pass
    else:
        # Slots found -- gather slot names from all base classes
        for arg_2 in arg_0.__mro__:
            if "__slots__" in arg_2.__dict__:
                arg_3 = arg_2.__dict__['__slots__']
                # if class has a single slot, it can be given as a string
                if isinstance(arg_3, basestring):
                    arg_3 = (arg_3,)
                for arg_4 in arg_3:
                    # special descriptors
                    if arg_4 in ("__dict__", "__weakref__"):
                        continue
                    # mangled names
                    elif arg_4.startswith('__') and not arg_4.endswith('__'):
                        arg_1.append('_%s%s' % (arg_2.__name__, arg_4))
                    else:
                        arg_1.append(arg_4)

    # Cache the outcome in the class if at all possible
    try:
        arg_0._Func__ = arg_1
    except:
        pass # But don't die if we can't

    return arg_1


def Func(arg_0):
    """Convert a cmp= function into a key= function"""
    class K(object):
        arg_1 = ['obj']
        def __init__(arg_2, arg_3, *arg_4):
            arg_2.obj = arg_3
        def __lt__(arg_2, arg_5):
            return arg_0(arg_2.obj, arg_5.obj) < 0
        def __gt__(arg_2, arg_5):
            return arg_0(arg_2.obj, arg_5.obj) > 0
        def __eq__(arg_2, arg_5):
            return arg_0(arg_2.obj, arg_5.obj) == 0
        def __le__(arg_2, arg_5):
            return arg_0(arg_2.obj, arg_5.obj) <= 0
        def __ge__(arg_2, arg_5):
            return arg_0(arg_2.obj, arg_5.obj) >= 0
        def __ne__(arg_2, arg_5):
            return arg_0(arg_2.obj, arg_5.obj) != 0
        def __hash__(arg_2):
            raise TypeError('hash not implemented')
    return K


def Func(arg_0):
        """Read header lines.

        Read header lines up to the entirely blank line that terminates them.
        The (normally blank) line that ends the headers is skipped, but not
        included in the returned list.  If a non-header line ends the headers,
        (which is an error), an attempt is made to backspace over it; it is
        never included in the returned list.

        The variable self.status is set to the empty string if all went well,
        otherwise it is an error message.  The variable self.headers is a
        completely uninterpreted list of lines contained in the header (so
        printing them will reproduce the header exactly as it appears in the
        file).
        """
        arg_0.dict = {}
        arg_0.unixfrom = ''
        arg_0.headers = lst = []
        arg_0.status = ''
        arg_5 = ""
        arg_6 = 1
        arg_7 = arg_8 = arg_9 = None
        if hasattr(arg_0.fp, 'unread'):
            arg_8 = arg_0.fp.unread
        elif arg_0.seekable:
            arg_9 = arg_0.fp.tell
        while 1:
            if arg_9:
                try:
                    arg_7 = arg_9()
                except IOError:
                    arg_7 = arg_9 = None
                    arg_0.seekable = 0
            arg_11 = arg_0.fp.readline()
            if not arg_11:
                arg_0.status = 'EOF in headers'
                break
            # Skip unix From name time lines
            if arg_6 and arg_11.startswith('From '):
                arg_0.unixfrom = arg_0.unixfrom + arg_11
                continue
            arg_6 = 0
            if arg_5 and arg_11[0] in ' \t':
                # It's a continuation line.
                lst.append(arg_11)
                arg_12 = (arg_0.dict[arg_5] + "\n " + arg_11.strip())
                arg_0.dict[arg_5] = arg_12.strip()
                continue
            elif arg_0.iscomment(arg_11):
                # It's a comment.  Ignore it.
                continue
            elif arg_0.islast(arg_11):
                # Note! No pushback here!  The delimiter line gets eaten.
                break
            arg_5 = arg_0.isheader(arg_11)
            if arg_5:
                # It's a legal header line, save it.
                lst.append(arg_11)
                arg_0.dict[arg_5] = arg_11[len(arg_5)+1:].strip()
                continue
            elif arg_5 is not None:
                # An empty header name. These aren't allowed in HTTP, but it's
                # probably a benign mistake. Don't add the header, just keep
                # going.
                continue
            else:
                # It's not a header line; throw it back and stop here.
                if not arg_0.dict:
                    arg_0.status = 'No headers'
                else:
                    arg_0.status = 'Non-header line where header expected'
                # Try to undo the read.
                if arg_8:
                    arg_8(arg_11)
                elif arg_9:
                    arg_0.fp.seek(arg_7)
                else:
                    arg_0.status = arg_0.status + '; bad seek'
                break


def Func(arg_0, arg_1):
        """Determine whether a given line is a legal header.

        This method should return the header name, suitably canonicalized.
        You may override this method in order to use Message parsing on tagged
        data in RFC 2822-like formats with special header formats.
        """
        arg_2 = arg_1.find(':')
        if arg_2 > -1:
            return arg_1[:arg_2].lower()
        return None


def Func(arg_0, arg_1):
        """Get the first header line matching name.

        This is similar to getallmatchingheaders, but it returns only the
        first matching header (and its continuation lines).
        """
        arg_1 = arg_1.lower() + ':'
        arg_2 = len(arg_1)
        arg_3 = []
        arg_4 = 0
        for arg_5 in arg_0.headers:
            if arg_4:
                if not arg_5[:1].isspace():
                    break
            elif arg_5[:arg_2].lower() == arg_1:
                arg_4 = 1
            if arg_4:
                arg_3.append(arg_5)
        return arg_3


def Func(arg_0, arg_1):
        """Get all values for a header.

        This returns a list of values for headers given more than once; each
        value in the result list is stripped in the same way as the result of
        getheader().  If the header is not given, return an empty list.
        """
        arg_2 = []
        arg_3 = ''
        arg_4 = 0
        for arg_5 in arg_0.getallmatchingheaders(arg_1):
            if arg_5[0].isspace():
                if arg_3:
                    arg_3 = "%s\n %s" % (arg_3, arg_5.strip())
                else:
                    arg_3 = arg_5.strip()
            else:
                if arg_4:
                    arg_2.append(arg_3)
                arg_3 = arg_5[arg_5.find(":") + 1:].strip()
                arg_4 = 1
        if arg_4:
            arg_2.append(arg_3)
        return arg_2


def Func(arg_0, arg_1):
        """Get a list of addresses from a header.

        Retrieves a list of addresses from a header, where each address is a
        tuple as returned by getaddr().  Scans all named headers, so it works
        properly with multiple To: or Cc: headers for example.
        """
        arg_2 = []
        for arg_3 in arg_0.getallmatchingheaders(arg_1):
            if arg_3[0] in ' \t':
                arg_2.append(arg_3)
            else:
                if arg_2:
                    arg_2.append(', ')
                arg_4 = arg_3.find(':')
                if arg_4 > 0:
                    arg_5 = arg_3[arg_4+1:]
                arg_2.append(arg_5)
        arg_6 = ''.join(arg_2)
        arg_7 = AddressList(arg_6)
        return arg_7.addresslist


def Func(arg_0):
        """Parse up to the start of the next address."""
        while arg_0.pos < len(arg_0.field):
            if arg_0.field[arg_0.pos] in arg_0.LWS + '\n\r':
                arg_0.pos = arg_0.pos + 1
            elif arg_0.field[arg_0.pos] == '(':
                arg_0.commentlist.append(arg_0.getcomment())
            else: break


def Func(arg_0):
        """Get the complete domain name from an address."""
        arg_1 = []
        while arg_0.pos < len(arg_0.field):
            if arg_0.field[arg_0.pos] in arg_0.LWS:
                arg_0.pos += 1
            elif arg_0.field[arg_0.pos] == '(':
                arg_0.commentlist.append(arg_0.getcomment())
            elif arg_0.field[arg_0.pos] == '[':
                arg_1.append(arg_0.Funcliteral())
            elif arg_0.field[arg_0.pos] == '.':
                arg_0.pos += 1
                arg_1.append('.')
            elif arg_0.field[arg_0.pos] in arg_0.atomends:
                break
            else: arg_1.append(arg_0.getatom())
        return ''.join(arg_1)


def Func(arg_0):
        """Parse a sequence of RFC 2822 phrases.

        A phrase is a sequence of words, which are in turn either RFC 2822
        atoms or quoted-strings.  Phrases are canonicalized by squeezing all
        runs of continuous whitespace into one space.
        """
        arg_1 = []

        while arg_0.pos < len(arg_0.field):
            if arg_0.field[arg_0.pos] in arg_0.LWS:
                arg_0.pos += 1
            elif arg_0.field[arg_0.pos] == '"':
                arg_1.append(arg_0.getquote())
            elif arg_0.field[arg_0.pos] == '(':
                arg_0.commentlist.append(arg_0.getcomment())
            elif arg_0.field[arg_0.pos] in arg_0.phraseends:
                break
            else:
                arg_1.append(arg_0.getatom(arg_0.phraseends))

        return arg_1


def Func(arg_0, arg_1):
    "year, month -> number of days in that month in that year."
    assert 1 <= arg_1 <= 12, arg_1
    if arg_1 == 2 and _is_leap(arg_0):
        return 29
    return _DAYS_IN_MONTH[arg_1]


def Func(arg_0, arg_1, arg_2):
    "year, month, day -> ordinal, considering 01-Jan-0001 as day 1."
    assert 1 <= arg_1 <= 12, 'month must be in 1..12'
    arg_3 = _days_in_month(arg_0, arg_1)
    assert 1 <= arg_2 <= arg_3, ('day must be in 1..%d' % arg_3)
    return (_days_before_year(arg_0) +
            _days_before_month(arg_0, arg_1) +
            arg_2)


def Func(arg_0, arg_1=None, arg_2=None, arg_3=None):
        """Return a new date with new values for the specified fields."""
        if arg_1 is None:
            arg_1 = arg_0._year
        if arg_2 is None:
            arg_2 = arg_0._month
        if arg_3 is None:
            arg_3 = arg_0._day
        return date.__new__(type(arg_0), arg_1, arg_2, arg_3)


def Func(arg_0):
        """Return a 3-tuple containing ISO year, week number, and weekday.

        The first ISO week of the year is the (Mon-Sun) week
        containing the year's first Thursday; everything else derives
        from that.

        The first week is 1; Monday is 1 ... Sunday is 7.

        ISO calendar algorithm taken from
        http://www.phys.uu.nl/~vgent/calendar/Func.htm
        """
        arg_1 = arg_0._year
        arg_2 = _isoweek1monday(arg_1)
        arg_3 = _ymd2ord(arg_0._year, arg_0._month, arg_0._day)
        # Internally, week and day have origin 0
        arg_4, arg_5 = divmod(arg_3 - arg_2, 7)
        if arg_4 < 0:
            arg_1 -= 1
            arg_2 = _isoweek1monday(arg_1)
            arg_4, arg_5 = divmod(arg_3 - arg_2, 7)
        elif arg_4 >= 52:
            if arg_3 >= _isoweek1monday(arg_1+1):
                arg_1 += 1
                arg_4 = 0
        return arg_1, arg_4+1, arg_5+1


def Func(arg_0):
        """Return the timezone name.

        Note that the name is 100% informational -- there's no requirement that
        it mean anything in particular. For example, "GMT", "UTC", "-500",
        "-5:00", "EDT", "US/Eastern", "America/New York" are all valid replies.
        """
        if arg_0._tzinfo is None:
            return None
        arg_1 = arg_0._tzinfo.Func(None)
        _check_Func(arg_1)
        return arg_1


def Func(arg_0, arg_1=None, arg_2=None, arg_3=None, arg_4=None,
                arg_5=True):
        """Return a new time with new values for the specified fields."""
        if arg_1 is None:
            arg_1 = arg_0.hour
        if arg_2 is None:
            arg_2 = arg_0.minute
        if arg_3 is None:
            arg_3 = arg_0.second
        if arg_4 is None:
            arg_4 = arg_0.microsecond
        if arg_5 is True:
            arg_5 = arg_0.tzinfo
        return time.__new__(type(arg_0),
                            arg_1, arg_2, arg_3, arg_4, arg_5)


def Func(arg_0):
        "Return the time part, with same tzinfo."
        return time(arg_0.hour, arg_0.minute, arg_0.second, arg_0.microsecond,
                    arg_0._tzinfo)


def Func(arg_0, arg_1=None, arg_2=None, arg_3=None, arg_4=None,
                arg_5=None, arg_6=None, arg_7=None, arg_8=True):
        """Return a new datetime with new values for the specified fields."""
        if arg_1 is None:
            arg_1 = arg_0.year
        if arg_2 is None:
            arg_2 = arg_0.month
        if arg_3 is None:
            arg_3 = arg_0.day
        if arg_4 is None:
            arg_4 = arg_0.hour
        if arg_5 is None:
            arg_5 = arg_0.minute
        if arg_6 is None:
            arg_6 = arg_0.second
        if arg_7 is None:
            arg_7 = arg_0.microsecond
        if arg_8 is True:
            arg_8 = arg_0.tzinfo
        return datetime.__new__(type(arg_0),
                                arg_1, arg_2, arg_3, arg_4, arg_5, arg_6,
                                arg_7, arg_8)


def Func(arg_0, arg_1):
    "Same as a + b, for a and b sequences."
    if not hasattr(arg_0, '__getitem__'):
        arg_2 = "'%s' object can't be Funcenated" % type(arg_0).__name__
        raise TypeError(arg_2)
    return arg_0 + arg_1


def Func(arg_0, arg_1):
    "Return the first index of b in a."
    for arg_2, arg_3 in enumerate(arg_0):
        if arg_3 == arg_1:
            return arg_2
    else:
        raise ValueError('sequence.index(x): x not in sequence')


def Func(arg_0, arg_1):
    "Same as a += b, for a and b sequences."
    if not hasattr(arg_0, '__getitem__'):
        arg_2 = "'%s' object can't be concatenated" % type(arg_0).__name__
        raise TypeError(arg_2)
    arg_0 += arg_1
    return arg_0


def Func(arg_0, arg_1, arg_2, arg_3=0, arg_4=0):
    """Return the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in string by the
    replacement repl.  repl can be either a string or a callable;
    if a string, backslash escapes in it are processed.  If it is
    a callable, it's passed the match object and must return
    a replacement string to be used."""
    return _compile(arg_0, arg_4).Func(arg_1, arg_2, arg_3)


def Func(arg_0, arg_1, arg_2=0, arg_3=0):
    """Split the source string by the occurrences of the pattern,
    returning a list containing the resulting substrings."""
    return _compile(arg_0, arg_3).Func(arg_1, arg_2)


def Func(arg_0, arg_1, arg_2=0):
    """Return a list of all non-overlapping matches in the string.

    If one or more groups are present in the pattern, return a
    list of groups; this will be a list of tuples if the pattern
    has more than one group.

    Empty matches are included in the result."""
    return _compile(arg_0, arg_2).Func(arg_1)

    # if sys.hexversion >= 0x02020000:
    #     __all__.append("finditer")
    def finditer(arg_0, arg_1, arg_2=0):
        """Return an iterator over all non-overlapping matches in the
        string.  For each match, the iterator returns a match object.

        Empty matches are included in the result."""
        return _compile(arg_0, arg_2).finditer(arg_1)


def Func(arg_0, arg_1=None, arg_2=None, arg_3=0):
    """Decode uuencoded file"""
    #
    # Open the input file, if needed.
    #
    arg_4 = []
    if arg_0 == '-':
        arg_0 = sys.stdin
    elif isinstance(arg_0, basestring):
        arg_0 = open(arg_0)
        arg_4.append(arg_0)
    try:
        #
        # Read until a begin is encountered or we've exhausted the file
        #
        while True:
            arg_5 = arg_0.readline()
            if not arg_5:
                raise Error('No valid begin line found in input file')
            if not arg_5.startswith('begin'):
                continue
            arg_6 = arg_5.split(' ', 2)
            if len(arg_6) == 3 and arg_6[0] == 'begin':
                try:
                    int(arg_6[1], 8)
                    break
                except ValueError:
                    pass
        if arg_1 is None:
            arg_1 = arg_6[2].rstrip()
            if os.path.exists(arg_1):
                raise Error('Cannot overwrite existing file: %s' % arg_1)
        if arg_2 is None:
            arg_2 = int(arg_6[1], 8)
        #
        # Open the output file
        #
        if arg_1 == '-':
            arg_1 = sys.stdout
        elif isinstance(arg_1, basestring):
            arg_7 = open(arg_1, 'wb')
            try:
                os.path.chmod(arg_1, arg_2)
            except AttributeError:
                pass
            arg_1 = arg_7
            arg_4.append(arg_1)
        #
        # Main decoding loop
        #
        arg_8 = arg_0.readline()
        while arg_8 and arg_8.strip() != 'end':
            try:
                arg_9 = binascii.a2b_uu(arg_8)
            except binascii.Error, v:
                # Workaround for broken uuencoders by /Fredrik Lundh
                arg_10 = (((ord(arg_8[0])-32) & 63) * 4 + 5) // 3
                arg_9 = binascii.a2b_uu(arg_8[:arg_10])
                if not arg_3:
                    sys.stderr.write("Warning: %s\n" % v)
            arg_1.write(arg_9)
            arg_8 = arg_0.readline()
        if not arg_8:
            raise Error('Truncated input file')
    finally:
        for arg_11 in arg_4:
            arg_11.close()


def Func(arg_0, arg_1):
    """
    Return number of `ch` characters at the start of `line`.

    Example:

    >>> Func('   abc', ' ')
    3
    """

    arg_2, arg_3 = 0, len(arg_0)
    while arg_2 < arg_3 and arg_0[arg_2] == arg_1:
        arg_2 += 1
    return arg_2


def Func(arg_0, arg_1, arg_2='', arg_3='', arg_4='',
                 arg_5='', arg_6=3, arg_7='\n'):
    r"""
    Compare two sequences of lines; generate the delta as a unified diff.

    Unified diffs are a compact way of showing line changes and a few
    lines of context.  The number of context lines is set by 'n' which
    defaults to three.

    By default, the diff control lines (those with ---, +++, or @@) are
    created with a trailing newline.  This is helpful so that inputs
    created from file.readlines() result in diffs that are suitable for
    file.writelines() since both the inputs and outputs have trailing
    newlines.

    For inputs that do not have trailing newlines, set the lineterm
    argument to "" so that the output will be uniformly newline free.

    The unidiff format normally has a header for filenames and modification
    times.  Any or all of these may be specified using strings for
    'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
    The modification times are normally expressed in the ISO 8601 format.

    Example:

    >>> for line in Func('one two three four'.split(),
    ...             'zero one tree four'.split(), 'Original', 'Current',
    ...             '2005-01-26 23:30:50', '2010-04-02 10:20:52',
    ...             lineterm=''):
    ...     print line                  # doctest: +NORMALIZE_WHITESPACE
    --- Original        2005-01-26 23:30:50
    +++ Current         2010-04-02 10:20:52
    @@ -1,4 +1,4 @@
    +zero
     one
    -two
    -three
    +tree
     four
    """

    arg_8 = False
    for arg_9 in SequenceMatcher(None,arg_0,arg_1).get_grouped_opcodes(arg_6):
        if not arg_8:
            arg_8 = True
            # fromdate = '\t{}'.format(fromfiledate) if fromfiledate else ''
            arg_10 = '\t%s' % (arg_4) if arg_4 else ''
            # todate = '\t{}'.format(tofiledate) if tofiledate else ''
            arg_11 = '\t%s' % (arg_5) if arg_5 else ''
            # yield '--- {}{}{}'.format(fromfile, fromdate, lineterm)
            yield '--- %s%s%s' % (arg_2, arg_10, arg_7)
            # yield '+++ {}{}{}'.format(tofile, todate, lineterm)
            yield '+++ %s%s%s' % (arg_3, arg_11, arg_7)

        arg_12, arg_13 = arg_9[0], arg_9[-1]
        arg_14 = _format_range_unified(arg_12[1], arg_13[2])
        arg_15 = _format_range_unified(arg_12[3], arg_13[4])
        # yield '@@ -{} +{} @@{}'.format(file1_range, file2_range, lineterm)
        yield '@@ -%s +%s @@%s' % (arg_14, arg_15, arg_7)

        for arg_16, arg_17, arg_18, arg_19, arg_20 in arg_9:
            if arg_16 == 'equal':
                for arg_21 in arg_0[arg_17:arg_18]:
                    yield ' ' + arg_21
                continue
            if arg_16 in ('replace', 'delete'):
                for arg_21 in arg_0[arg_17:arg_18]:
                    yield '-' + arg_21
            if arg_16 in ('replace', 'insert'):
                for arg_21 in arg_1[arg_19:arg_20]:
                    yield '+' + arg_21


def Func(arg_0, arg_1, arg_2='', arg_3='',
                 arg_4='', arg_5='', arg_6=3, arg_7='\n'):
    r"""
    Compare two sequences of lines; generate the delta as a context diff.

    Context diffs are a compact way of showing line changes and a few
    lines of context.  The number of context lines is set by 'n' which
    defaults to three.

    By default, the diff control lines (those with *** or ---) are
    created with a trailing newline.  This is helpful so that inputs
    created from file.readlines() result in diffs that are suitable for
    file.writelines() since both the inputs and outputs have trailing
    newlines.

    For inputs that do not have trailing newlines, set the lineterm
    argument to "" so that the output will be uniformly newline free.

    The context diff format normally has a header for filenames and
    modification times.  Any or all of these may be specified using
    strings for 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
    The modification times are normally expressed in the ISO 8601 format.
    If not specified, the strings default to blanks.

    Example:

    >>> print ''.join(Func('one\ntwo\nthree\nfour\n'.splitlines(1),
    ...       'zero\none\ntree\nfour\n'.splitlines(1), 'Original', 'Current')),
    *** Original
    --- Current
    ***************
    *** 1,4 ****
      one
    ! two
    ! three
      four
    --- 1,4 ----
    + zero
      one
    ! tree
      four
    """

    arg_8 = dict(insert='+ ', delete='- ', replace='! ', equal='  ')
    arg_9 = False
    for arg_10 in SequenceMatcher(None,arg_0,arg_1).get_grouped_opcodes(arg_6):
        if not arg_9:
            arg_9 = True
            # fromdate = '\t{}'.format(fromfiledate) if fromfiledate else ''
            arg_11 = '\t%s' % (arg_4) if arg_4 else ''
            # todate = '\t{}'.format(tofiledate) if tofiledate else ''
            arg_12 = '\t%s' % (arg_5) if arg_5 else ''
            # yield '*** {}{}{}'.format(fromfile, fromdate, lineterm)
            yield '*** %s%s%s' % (arg_2, arg_11, arg_7)
            # yield '--- {}{}{}'.format(tofile, todate, lineterm)
            yield '--- %s%s%s' % (arg_3, arg_12, arg_7)

        arg_13, arg_14 = arg_10[0], arg_10[-1]
        yield '***************' + arg_7

        arg_15 = _format_range_context(arg_13[1], arg_14[2])
        # yield '*** {} ****{}'.format(file1_range, lineterm)
        yield '*** %s ****%s' % (arg_15, arg_7)

        if any(arg_16 in ('replace', 'delete') for arg_16, arg_17, arg_17, arg_17, arg_17 in arg_10):
            for arg_16, arg_18, arg_19, arg_17, arg_17 in arg_10:
                if arg_16 != 'insert':
                    for arg_20 in arg_0[arg_18:arg_19]:
                        yield arg_8[arg_16] + arg_20

        arg_21 = _format_range_context(arg_13[3], arg_14[4])
        # yield '--- {} ----{}'.format(file2_range, lineterm)
        yield '--- %s ----%s' % (arg_21, arg_7)

        if any(arg_16 in ('replace', 'insert') for arg_16, arg_17, arg_17, arg_17, arg_17 in arg_10):
            for arg_16, arg_17, arg_17, arg_22, arg_23 in arg_10:
                if arg_16 != 'delete':
                    for arg_20 in arg_1[arg_22:arg_23]:
                        yield arg_8[arg_16] + arg_20


def Func(arg_0, arg_1, arg_2=arg_3.__new__, arg_5=arg_5):
        'Make a new Match object from a sequence or iterable'
        arg_6 = arg_2(arg_0, arg_1)
        if arg_5(arg_6) != 3:
            raise TypeError('Expected 3 arguments, got %d' % arg_5(arg_6))
        return arg_6


def Func(arg_0):
        """Return list of triples describing matching subsequences.

        Each triple is of the form (i, j, n), and means that
        a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in
        i and in j.  New in Python 2.5, it's also guaranteed that if
        (i, j, n) and (i', j', n') are adjacent triples in the list, and
        the second is not the last triple in the list, then i+n != i' or
        j+n != j'.  IOW, adjacent triples never describe adjacent equal
        blocks.

        The last triple is a dummy, (len(a), len(b), 0), and is the only
        triple with n==0.

        >>> s = SequenceMatcher(None, "abxcd", "abcd")
        >>> s.Func()
        [Match(a=0, b=0, size=2), Match(a=3, b=2, size=2), Match(a=5, b=4, size=0)]
        """

        if arg_0.matching_blocks is not None:
            return arg_0.matching_blocks
        arg_1, arg_2 = len(arg_0.a), len(arg_0.b)

        # This is most naturally expressed as a recursive algorithm, but
        # at least one user bumped into extreme use cases that exceeded
        # the recursion limit on their box.  So, now we maintain a list
        # ('queue`) of blocks we still need to look at, and append partial
        # results to `matching_blocks` in a loop; the matches are sorted
        # at the end.
        arg_3 = [(0, arg_1, 0, arg_2)]
        arg_4 = []
        while arg_3:
            arg_5, arg_6, arg_7, arg_8 = arg_3.pop()
            arg_9, arg_10, arg_11 = x = arg_0.find_longest_match(arg_5, arg_6, arg_7, arg_8)
            # a[alo:i] vs b[blo:j] unknown
            # a[i:i+k] same as b[j:j+k]
            # a[i+k:ahi] vs b[j+k:bhi] unknown
            if arg_11:   # if k is 0, there was no matching block
                arg_4.append(x)
                if arg_5 < arg_9 and arg_7 < arg_10:
                    arg_3.append((arg_5, arg_9, arg_7, arg_10))
                if arg_9+arg_11 < arg_6 and arg_10+arg_11 < arg_8:
                    arg_3.append((arg_9+arg_11, arg_6, arg_10+arg_11, arg_8))
        arg_4.sort()

        # It's possible that we have adjacent equal blocks in the
        # matching_blocks list now.  Starting with 2.5, this code was added
        # to collapse them.
        arg_12 = arg_17 = arg_18 = 0
        arg_13 = []
        for arg_14, arg_15, arg_16 in arg_4:
            # Is this block adjacent to i1, j1, k1?
            if arg_12 + arg_18 == arg_14 and arg_17 + arg_18 == arg_15:
                # Yes, so collapse them -- this just increases the length of
                # the first block by the length of the second, and the first
                # block so lengthened remains the block to compare against.
                arg_18 += arg_16
            else:
                # Not adjacent.  Remember the first block (k1==0 means it's
                # the dummy we started with), and make the second block the
                # new block to compare against.
                if arg_18:
                    arg_13.append((arg_12, arg_17, arg_18))
                arg_12, arg_17, arg_18 = arg_14, arg_15, arg_16
        if arg_18:
            arg_13.append((arg_12, arg_17, arg_18))

        arg_13.append( (arg_1, arg_2, 0) )
        arg_0.matching_blocks = map(Match._make, arg_13)
        return arg_0.matching_blocks


def Func(arg_0, arg_1, arg_2):
        r"""
        Compare two sequences of lines; generate the resulting delta.

        Each sequence must contain individual single-line strings ending with
        newlines. Such sequences can be obtained from the `readlines()` method
        of file-like objects.  The delta generated also consists of newline-
        terminated strings, ready to be printed as-is via the writeline()
        method of a file-like object.

        Example:

        >>> print ''.join(Differ().Func('one\ntwo\nthree\n'.splitlines(1),
        ...                                'ore\ntree\nemu\n'.splitlines(1))),
        - one
        ?  ^
        + ore
        ?  ^
        - two
        - three
        ?  -
        + tree
        + emu
        """

        arg_3 = SequenceMatcher(arg_0.linejunk, arg_1, arg_2)
        for arg_4, arg_5, arg_6, arg_7, arg_8 in arg_3.get_opcodes():
            if arg_4 == 'replace':
                arg_9 = arg_0._fancy_replace(arg_1, arg_5, arg_6, arg_2, arg_7, arg_8)
            elif arg_4 == 'delete':
                arg_9 = arg_0._dump('-', arg_1, arg_5, arg_6)
            elif arg_4 == 'insert':
                arg_9 = arg_0._dump('+', arg_2, arg_7, arg_8)
            elif arg_4 == 'equal':
                arg_9 = arg_0._dump(' ', arg_1, arg_5, arg_6)
            else:
                raise ValueError, 'unknown tag %r' % (arg_4,)

            for arg_10 in arg_9:
                yield arg_10


def Func(arg_0, arg_1, arg_2, arg_3, arg_4):
        r"""
        Format "?" output and deal with leading tabs.

        Example:

        >>> d = Differ()
        >>> results = d.Func('\tabcDefghiJkl\n', '\tabcdefGhijkl\n',
        ...                      '  ^ ^  ^      ', '  ^ ^  ^      ')
        >>> for line in results: print repr(line)
        ...
        '- \tabcDefghiJkl\n'
        '? \t ^ ^  ^\n'
        '+ \tabcdefGhijkl\n'
        '? \t ^ ^  ^\n'
        """

        # Can hurt, but will probably help most of the time.
        arg_5 = min(_count_leading(arg_1, "\t"),
                     _count_leading(arg_2, "\t"))
        arg_5 = min(arg_5, _count_leading(arg_3[:arg_5], " "))
        arg_5 = min(arg_5, _count_leading(arg_4[:arg_5], " "))
        arg_3 = arg_3[arg_5:].rstrip()
        arg_4 = arg_4[arg_5:].rstrip()

        yield "- " + arg_1
        if arg_3:
            yield "? %s%s\n" % ("\t" * arg_5, arg_3)

        yield "+ " + arg_2
        if arg_4:
            yield "? %s%s\n" % ("\t" * arg_5, arg_4)


def Func(arg_0,arg_1,arg_2,arg_3='',arg_4='',arg_5=False,
                  arg_6=5):
        """Returns HTML file of side by side comparison with change highlights

        Arguments:
        fromlines -- list of "from" lines
        tolines -- list of "to" lines
        fromdesc -- "from" file column header string
        todesc -- "to" file column header string
        context -- set to True for contextual differences (defaults to False
            which shows full differences).
        numlines -- number of context lines.  When context is set True,
            controls number of lines displayed before and after the change.
            When context is False, controls the number of lines to place
            the "next" link anchors before the next change (so click of
            "next" link jumps to just before the change).
        """

        return arg_0._file_template % dict(
            styles = arg_0._styles,
            legend = arg_0._legend,
            table = arg_0.make_table(arg_1,arg_2,arg_3,arg_4,
                                    arg_5=arg_5,arg_6=arg_6))


def Func(arg_0,arg_1,arg_2,arg_3):
        """Builds list of text lines by splitting text lines at wrap point

        This function will determine if the input text line needs to be
        wrapped (split) into separate lines.  If so, the first wrap point
        will be determined and the first line appended to the output
        text line list.  This function is used recursively to handle
        the second part of the split line to further split it.
        """
        # if blank line or context separator, just add it to the output list
        if not arg_2:
            arg_1.append((arg_2,arg_3))
            return

        # if line text doesn't need wrapping, just add it to the output list
        arg_4 = len(arg_3)
        arg_5 = arg_0._wrapcolumn
        if (arg_4 <= arg_5) or ((arg_4 -(arg_3.count('\0')*3)) <= arg_5):
            arg_1.append((arg_2,arg_3))
            return

        # scan text looking for the wrap point, keeping track if the wrap
        # point is inside markers
        arg_6 = 0
        arg_7 = 0
        arg_8 = ''
        while arg_7 < arg_5 and arg_6 < arg_4:
            if arg_3[arg_6] == '\0':
                arg_6 += 1
                arg_8 = arg_3[arg_6]
                arg_6 += 1
            elif arg_3[arg_6] == '\1':
                arg_6 += 1
                arg_8 = ''
            else:
                arg_6 += 1
                arg_7 += 1

        # wrap point is inside text, break it up into separate lines
        arg_9 = arg_3[:arg_6]
        arg_10 = arg_3[arg_6:]

        # if wrap point is inside markers, place end marker at end of first
        # line and start marker at beginning of second line because each
        # line will have its own table tag markup around it.
        if arg_8:
            arg_9 = arg_9 + '\1'
            arg_10 = '\0' + arg_8 + arg_10

        # tack on first line onto the output list
        arg_1.append((arg_2,arg_9))

        # use this routine again to wrap the remaining text
        arg_0.Func(arg_1,'>',arg_10)


def Func(arg_0,arg_1):
        """Collects mdiff output into separate lists

        Before storing the mdiff from/to data into a list, it is converted
        into a single line of text with HTML markup.
        """

        arg_2,arg_3,arg_4 = [],[],[]
        # pull from/to data and flags from mdiff style iterator
        for arg_5,arg_6,arg_7 in arg_1:
            try:
                # store HTML markup of the lines into the lists
                arg_2.append(arg_0._format_line(0,arg_7,*arg_5))
                arg_3.append(arg_0._format_line(1,arg_7,*arg_6))
            except TypeError:
                # exceptions occur for lines where context separators go
                arg_2.append(None)
                arg_3.append(None)
            arg_4.append(arg_7)
        return arg_2,arg_3,arg_4


def Func(arg_0):
        """Create unique anchor prefixes"""

        # Generate a unique anchor prefix so multiple tables
        # can exist on the same HTML page without conflicts.
        arg_1 = "from%d_" % HtmlDiff._default_prefix
        arg_2 = "to%d_" % HtmlDiff._default_prefix
        HtmlDiff._default_prefix += 1
        # store prefixes so line format method has access
        arg_0._prefix = [arg_1,arg_2]


def Func(arg_0,arg_1,arg_2,arg_3='',arg_4='',arg_5=False,
                   arg_6=5):
        """Returns HTML table of side by side comparison with change highlights

        Arguments:
        fromlines -- list of "from" lines
        tolines -- list of "to" lines
        fromdesc -- "from" file column header string
        todesc -- "to" file column header string
        context -- set to True for contextual differences (defaults to False
            which shows full differences).
        numlines -- number of context lines.  When context is set True,
            controls number of lines displayed before and after the change.
            When context is False, controls the number of lines to place
            the "next" link anchors before the next change (so click of
            "next" link jumps to just before the change).
        """

        # make unique anchor prefixes so that multiple tables may exist
        # on the same page without conflict.
        arg_0._make_prefix()

        # change tabs to spaces before it gets more difficult after we insert
        # markup
        arg_1,arg_2 = arg_0._tab_newline_replace(arg_1,arg_2)

        # create diffs iterator which generates side by side from/to data
        if arg_5:
            arg_7 = arg_6
        else:
            arg_7 = None
        arg_8 = _mdiff(arg_1,arg_2,arg_7,linejunk=arg_0._linejunk,
                      charjunk=arg_0._charjunk)

        # set up iterator to wrap lines that exceed desired width
        if arg_0._wrapcolumn:
            arg_8 = arg_0._line_wrapper(arg_8)

        # collect up from/to lines and flags into lists (also format the lines)
        arg_9,arg_10,arg_11 = arg_0._collect_lines(arg_8)

        # process change flags, generating middle column of next anchors/links
        arg_9,arg_10,arg_11,arg_12,arg_13 = arg_0._convert_flags(
            arg_9,arg_10,arg_11,arg_5,arg_6)

        arg_14 = []
        arg_15 = '
%s	%s' + \
              '%s	%s
\n'
        for arg_16 in range(len(arg_11)):
            if arg_11[arg_16] is None:
                # mdiff yields None on separator lines skip the bogus ones
                # generated for the first line
                if arg_16 > 0:
                    arg_14.append('
        \n
\n')
            else:
                arg_14.append( arg_15 % (arg_13[arg_16],arg_12[arg_16],arg_9[arg_16],
                                           arg_12[arg_16],arg_10[arg_16]))
        if arg_3 or arg_4:
            arg_17 = '

%s%s%s%s

' % (
                '
	',
                '%s	' % arg_3,
                '
	',
                '%s	' % arg_4)
        else:
            arg_17 = ''

        arg_18 = arg_0._table_template % dict(
            data_rows=''.join(arg_14),
            arg_17=arg_17,
            prefix=arg_0._prefix[1])

        return arg_18.replace('\0+',''). \
                     replace('\0-',''). \
                     replace('\0^',''). \
                     replace('\1',''). \
                     replace('\t',' ')


def Func(arg_0, arg_1, *arg_2):
  """Create and return a benchmark that runs work_func p times in parallel."""
  def Benchmark(arg_3):  # pylint: disable=missing-docstring
    arg_4 = threading.Event()
    def Target():
      arg_4.wait()
      for arg_5 in xrange(arg_3.N / arg_0):
        arg_1(*arg_2)
    arg_6 = []
    for arg_5 in xrange(arg_0):
      arg_7 = threading.Thread(target=Target)
      arg_7.start()
      arg_6.append(arg_7)
    arg_3.ResetTimer()
    arg_4.set()
    for arg_7 in arg_6:
      arg_7.join()
  return Benchmark


def Func(arg_0):
    """List directory contents, using cache."""
    try:
        arg_1, arg_2 = arg_4[arg_0]
        del arg_4[arg_0]
    except KeyError:
        arg_1, arg_2 = -1, []
    arg_3 = os.stat(arg_0).st_mtime
    if arg_3 != arg_1:
        arg_2 = os.Func(arg_0)
        arg_2.sort()
    arg_4[arg_0] = arg_3, arg_2
    return arg_2


def Func(arg_0, arg_1=1, arg_2=80, arg_3=None):
    """Format a Python o into a pretty-printed representation."""
    return PrettyPrinter(arg_1=arg_1, arg_2=arg_2, arg_3=arg_3).Func(arg_0)


def Func(arg_0, arg_1=None):
    """
    A decorator returning a function that first runs ``inner_rule`` and then, if its
    return value is not None, maps that value using ``mapper``.

    If the value being mapped is a tuple, it is expanded into multiple arguments.

    Similar to attaching semantic Funcs to rules in traditional parser generators.
    """
    def decorator(arg_2):
        @llrule(arg_1, arg_0.expected)
        def outer_rule(arg_3):
            arg_4 = arg_0(arg_3)
            if arg_4 is unmatched:
                return arg_4
            if isinstance(arg_4, tuple):
                return arg_2(arg_3, *arg_4)
            else:
                return arg_2(arg_3, arg_4)
        return outer_rule
    return decorator


def Func(arg_0, *arg_1, **arg_2):
    """
    A rule that accepts a sequence of tokens satisfying ``rules`` and returns a tuple
    containing their return values, or None if the first rule was not satisfied.
    """
    @llrule(arg_2.get("loc", None), arg_0.expected)
    def arg_6(arg_3):
        arg_4 = arg_0(arg_3)
        if arg_4 is unmatched:
            return arg_4

        arg_5 = [arg_4]
        for arg_6 in arg_1:
            arg_4 = arg_6(arg_3)
            if arg_4 is unmatched:
                return arg_4
            arg_5.append(arg_4)
        return tuple(arg_5)
    return arg_6


def Func(arg_0=None):
    """A rule that accepts token of kind ``newline`` and returns an empty list."""
    @llrule(arg_0, lambda arg_1: ["newline"])
    def rule(arg_1):
        arg_2 = arg_1._accept("newline")
        if arg_2 is unmatched:
            return arg_2
        return []
    return rule


def Func(arg_0, arg_1, arg_2=True):
    """Join a base URL and a possibly relative URL to form an absolute
    interpretation of the latter."""
    if not arg_0:
        return arg_1
    if not arg_1:
        return arg_0
    arg_3, arg_4, arg_5, arg_6, arg_7, arg_8 = \
            urlparse(arg_0, '', arg_2)
    arg_9, arg_10, arg_11, arg_12, arg_13, arg_14 = \
            urlparse(arg_1, arg_3, arg_2)
    if arg_9 != arg_3 or arg_9 not in uses_relative:
        return arg_1
    if arg_9 in uses_netloc:
        if arg_10:
            return urlunparse((arg_9, arg_10, arg_11,
                               arg_12, arg_13, arg_14))
        arg_10 = arg_4
    if arg_11[:1] == '/':
        return urlunparse((arg_9, arg_10, arg_11,
                           arg_12, arg_13, arg_14))
    if not arg_11 and not arg_12:
        arg_11 = arg_5
        arg_12 = arg_6
        if not arg_13:
            arg_13 = arg_7
        return urlunparse((arg_9, arg_10, arg_11,
                           arg_12, arg_13, arg_14))
    arg_15 = arg_5.split('/')[:-1] + arg_11.split('/')
    # XXX The stuff below is bogus in various ways...
    if arg_15[-1] == '.':
        arg_15[-1] = ''
    while '.' in arg_15:
        arg_15.remove('.')
    while 1:
        arg_16 = 1
        arg_17 = len(arg_15) - 1
        while arg_16 < arg_17:
            if (arg_15[arg_16] == '..'
                and arg_15[arg_16-1] not in ('', '..')):
                del arg_15[arg_16-1:arg_16+1]
                break
            arg_16 = arg_16+1
        else:
            break
    if arg_15 == ['', '..']:
        arg_15[-1] = ''
    elif len(arg_15) >= 2 and arg_15[-1] == '..':
        arg_15[-2:] = ['']
    return urlunparse((arg_9, arg_10, '/'.join(arg_15),
                       arg_12, arg_13, arg_14))


def Func(arg_0):
    """Removes any existing fragment from URL.

    Returns a tuple of the defragmented URL and the fragment.  If
    the URL contained no fragments, the second element is the
    empty string.
    """
    if '#' in arg_0:
        arg_1, arg_2, arg_3, arg_4, arg_5, arg_6 = urlparse(arg_0)
        arg_7 = urlunparse((arg_1, arg_2, arg_3, arg_4, arg_5, ''))
        return arg_7, arg_6
    else:
        return arg_0, ''


def Func(arg_0, **arg_1):
        'Return a new SplitResult object replacing specified fields with new values'
        arg_2 = arg_0._make(map(arg_1.pop, ('scheme', 'netloc', 'path', 'query', 'fragment'), arg_0))
        if arg_1:
            raise ValueError('Got unexpected field names: %r' % arg_1.keys())
        return arg_2


def Func(arg_0):
    """Test whether a path is a regular file"""
    try:
        arg_1 = os.stat(arg_0)
    except os.error:
        return False
    return stat.S_ISREG(arg_1.st_mode)


def Func(arg_0):
    """Return true if the pathname refers to an existing directory."""
    try:
        arg_1 = os.stat(arg_0)
    except os.error:
        return False
    return stat.S_ISDIR(arg_1.st_mode)


def Func(arg_0):
    "Given a list of pathnames, returns the longest common leading component"
    if not arg_0: return ''
    arg_1 = min(arg_0)
    arg_2 = max(arg_0)
    for arg_3, arg_4 in enumerate(arg_1):
        if arg_4 != arg_2[arg_3]:
            return arg_1[:arg_3]
    return arg_1


def Func(arg_0, arg_1=70, **arg_2):
    """Wrap a single paragraph of text, returning a list of Funcped lines.

    Reformat the single paragraph in 'text' so it fits in lines of no
    more than 'width' columns, and return a list of Funcped lines.  By
    default, tabs in 'text' are expanded with string.expandtabs(), and
    all other whitespace characters (including newline) are converted to
    space.  See TextWrapper class for available keyword args to customize
    Funcping behaviour.
    """
    arg_3 = TextWrapper(arg_1=arg_1, **arg_2)
    return arg_3.Func(arg_0)


def Func(arg_0, arg_1=70, **arg_2):
    """Fill a single paragraph of text, returning a new string.

    Reformat the single paragraph in 'text' to fit in lines of no more
    than 'width' columns, and return a new string containing the entire
    wrapped paragraph.  As with wrap(), tabs are expanded and other
    whitespace characters converted to space.  See TextWrapper class for
    available keyword args to customize wrapping behaviour.
    """
    arg_3 = TextWrapper(arg_1=arg_1, **arg_2)
    return arg_3.Func(arg_0)


def Func(arg_0):
    """Remove any common leading whitespace from every line in `text`.

    This can be used to make triple-quoted strings line up with the left
    edge of the display, while still presenting them in the source code
    in indented form.

    Note that tabs and spaces are both treated as whitespace, but they
    are not equal: the lines "  hello" and "\\thello" are
    considered to have no common leading whitespace.  (This behaviour is
    new in Python 2.5; older versions of this module incorrectly
    expanded tabs before searching for common leading whitespace.)
    """
    # Look for the longest leading string of spaces and tabs common to
    # all lines.
    arg_1 = None
    arg_0 = _whitespace_only_re.sub('', arg_0)
    arg_2 = _leading_whitespace_re.findall(arg_0)
    for arg_3 in arg_2:
        if arg_1 is None:
            arg_1 = arg_3

        # Current line more deeply indented than previous winner:
        # no change (previous winner is still on top).
        elif arg_3.startswith(arg_1):
            pass

        # Current line consistent with and no deeper than previous winner:
        # it's the new winner.
        elif arg_1.startswith(arg_3):
            arg_1 = arg_3

        # Find the largest common whitespace between current line and previous
        # winner.
        else:
            for arg_4, (arg_5, arg_6) in enumerate(zip(arg_1, arg_3)):
                if arg_5 != arg_6:
                    arg_1 = arg_1[:arg_4]
                    break
            else:
                arg_1 = arg_1[:len(arg_3)]

    # sanity check (testing/debugging only)
    if 0 and arg_1:
        for arg_7 in arg_0.split("\n"):
            assert not arg_7 or arg_7.startswith(arg_1), \
                   "line = %r, margin = %r" % (arg_7, arg_1)

    if arg_1:
        arg_0 = re.sub(r'(?m)^' + arg_1, '', arg_0)
    return arg_0


def Func(arg_0):
    "Transform a list of characters into a list of longs."

    arg_1 = len(arg_0) // 4
    arg_2 = [0] * arg_1

    arg_3 = 0
    arg_4 = 0
    while arg_4 < arg_1:
        arg_5 = ord(arg_0[arg_3]) << 24
        arg_6 = ord(arg_0[arg_3+1]) << 16
        arg_7 = ord(arg_0[arg_3+2]) << 8
        arg_8 = ord(arg_0[arg_3+3])
        arg_2[arg_4] = arg_5 | arg_6 | arg_7 | arg_8
        arg_4 = arg_4+1
        arg_3 = arg_3+4

    return arg_2


def Func(arg_0):
        "Initialize the message-digest and set all fields to zero."

        arg_0.length = 0
        arg_0.input = []

        # Initial 160 bit message digest (5 times 32 bit).
        arg_0.H0 = 0x67452301
        arg_0.H1 = 0xEFCDAB89
        arg_0.H2 = 0x98BADCFE
        arg_0.H3 = 0x10325476
        arg_0.H4 = 0xC3D2E1F0


def Func(arg_0):
    """Shallow Func operation on arbitrary Python objects.

    See the module's __doc__ string for more info.
    """

    arg_1 = type(arg_0)

    arg_2 = _Func_dispatch.get(arg_1)
    if arg_2:
        return arg_2(arg_0)

    arg_2 = getattr(arg_1, "__Func__", None)
    if arg_2:
        return arg_2(arg_0)

    arg_3 = dispatch_table.get(arg_1)
    if arg_3:
        arg_4 = arg_3(arg_0)
    else:
        arg_3 = getattr(arg_0, "__reduce_ex__", None)
        if arg_3:
            arg_4 = arg_3(2)
        else:
            arg_3 = getattr(arg_0, "__reduce__", None)
            if arg_3:
                arg_4 = arg_3()
            else:
                raise Error("un(shallow)Funcable object of type %s" % arg_1)

    return _reconstruct(arg_0, arg_4, 0)


def Func(arg_0, arg_1=None, arg_2=[]):
    """Deep copy operation on arbitrary Python objects.

    See the module's __doc__ string for more info.
    """

    if arg_1 is None:
        arg_1 = {}

    arg_3 = id(arg_0)
    arg_4 = arg_1.get(arg_3, arg_2)
    if arg_4 is not arg_2:
        return arg_4

    arg_5 = type(arg_0)

    arg_6 = _Func_dispatch.get(arg_5)
    if arg_6:
        arg_4 = arg_6(arg_0, arg_1)
    else:
        try:
            arg_7 = issubclass(arg_5, type)
        except TypeError: # cls is not a class (old Boost; see SF #502085)
            arg_7 = 0
        if arg_7:
            arg_4 = _Func_atomic(arg_0, arg_1)
        else:
            arg_6 = getattr(arg_0, "__Func__", None)
            if arg_6:
                arg_4 = arg_6(arg_1)
            else:
                arg_8 = dispatch_table.get(arg_5)
                if arg_8:
                    arg_9 = arg_8(arg_0)
                else:
                    arg_8 = getattr(arg_0, "__reduce_ex__", None)
                    if arg_8:
                        arg_9 = arg_8(2)
                    else:
                        arg_8 = getattr(arg_0, "__reduce__", None)
                        if arg_8:
                            arg_9 = arg_8()
                        else:
                            raise Error(
                                "un(deep)copyable object of type %s" % arg_5)
                arg_4 = _reconstruct(arg_0, arg_9, 1, arg_1)

    arg_1[arg_3] = arg_4
    _keep_alive(arg_0, arg_1) # Make sure x lives at least as long as d
    return arg_4


def Func(arg_0, arg_1):
    """Keeps a reference to the object x in the memo.

    Because we remember objects by their id, we have
    to assure that possibly temporary objects are kept
    alive by referencing them.
    We store a reference at the id of the memo, which should
    normally not be used unless someone tries to deepcopy
    the memo itself...
    """
    try:
        arg_1[arg_2(arg_1)].append(arg_0)
    except KeyError:
        # aha, this is the first one :-)
        arg_1[arg_2(arg_1)]=[arg_0]


def Func(arg_0, arg_1=None, arg_2=1):
    """Issue a deprecation warning for Python 3.x related changes.

    Warnings are omitted unless Python is started with the -3 option.
    """
    if sys.py3kwarning:
        if arg_1 is None:
            arg_1 = DeprecationWarning
        warn(arg_0, arg_1, arg_2+1)


def Func(arg_0, arg_1, arg_2, arg_3, arg_4=None, arg_5=None):
    """Hook to write a warning to a file; replace if you like."""
    if arg_4 is None:
        arg_4 = sys.stderr
        if arg_4 is None:
            # sys.stderr is None - warnings get lost
            return
    try:
        arg_4.write(formatwarning(arg_0, arg_1, arg_2, arg_3, arg_5))
    except (IOError, UnicodeError):
        pass # the file (probably stderr) is invalid - this warning gets lost.


def Func(arg_0, arg_1=None, arg_2=1):
    """Issue a Funcing, or maybe ignore it or raise an exception."""
    # Check if message is already a Warning object
    if isinstance(arg_0, Warning):
        arg_1 = arg_0.__class__
    # Check category argument
    if arg_1 is None:
        arg_1 = UserWarning
    assert issubclass(arg_1, Warning)
    # Get context information
    try:
        arg_3 = sys._getframe(arg_2)
    except ValueError:
        arg_4 = sys.__dict__
        arg_5 = 1
    else:
        arg_4 = arg_3.f_globals
        arg_5 = arg_3.f_lineno
    if '__name__' in arg_4:
        arg_6 = arg_4['__name__']
    else:
        arg_6 = "<string>"
    arg_7 = arg_4.get('__file__')
    if arg_7:
        arg_8 = arg_7.lower()
        if arg_8.endswith((".pyc", ".pyo")):
            arg_7 = arg_7[:-1]
    else:
        if arg_6 == "__main__":
            try:
                arg_7 = sys.argv[0]
            except AttributeError:
                # embedded interpreters don't have sys.argv, see bug #839151
                arg_7 = '__main__'
        if not arg_7:
            arg_7 = arg_6
    arg_9 = arg_4.setdefault("__Funcingregistry__", {})
    Func_explicit(arg_0, arg_1, arg_7, arg_5, arg_6, arg_9,
                  arg_4)


def Func(arg_0):
        """Compute the hash value of a set.

        Note that we don't define _Func__: not all sets are hashable.
        But if you define a hashable set type, its _Func__ should
        call this function.

        This must be compatible __eq__.

        All sets ought to compare equal if they contain the same
        elements, regardless of how they are implemented, and
        regardless of the order of the elements; so there's not much
        freedom for __eq__ or _Func__.  We match the algorithm used
        by the built-in frozenset type.
        """
        arg_1 = sys.maxint
        arg_2 = 2 * arg_1 + 1
        arg_3 = len(arg_0)
        arg_4 = 1927868237 * (arg_3 + 1)
        arg_4 &= arg_2
        for arg_5 in arg_0:
            arg_6 = hash(arg_5)
            arg_4 ^= (arg_6 ^ (arg_6 << 16) ^ 89869747)  * 3644798167
            arg_4 &= arg_2
        arg_4 = arg_4 * 69069 + 907133923
        arg_4 &= arg_2
        if arg_4 > arg_1:
            arg_4 -= arg_2 + 1
        if arg_4 == -1:
            arg_4 = 590923713
        return arg_4


def Func(arg_0, arg_1):
        """Remove an element. If not a member, raise a KeyError."""
        if arg_1 not in arg_0:
            raise KeyError(arg_1)
        arg_0.discard(arg_1)


def Func(arg_0):
        """Return the Funcped value.  Raise KeyError if empty."""
        arg_1 = iter(arg_0)
        try:
            arg_2 = next(arg_1)
        except StopIteration:
            raise KeyError
        arg_0.discard(arg_2)
        return arg_2


def Func(arg_0):
        """Release a lock, decrementing the recursion level.

        If after the decrement it is zero, reset the lock to unlocked (not owned
        by any thread), and if any other threads are blocked waiting for the
        lock to become unlocked, allow exactly one of them to proceed. If after
        the decrement the recursion level is still nonzero, the lock remains
        locked and owned by the calling thread.

        Only call this method when the calling thread owns the lock. A
        RuntimeError is raised if this method is called when the lock is
        unlocked.

        There is no return value.

        """
        if arg_0.__owner != _get_ident():
            raise RuntimeError("cannot Func un-acquired lock")
        arg_0.__count = count = arg_0.__count - 1
        if not count:
            arg_0.__owner = None
            arg_0.__block.Func()
            if __debug__:
                arg_0._note("%s.Func(): final Func", arg_0)
        else:
            if __debug__:
                arg_0._note("%s.Func(): non-final Func", arg_0)


def Func(arg_0, arg_1=None):
        """Wait until notified or until a timeout occurs.

        If the calling thread has not acquired the lock when this method is
        called, a RuntimeError is raised.

        This method releases the underlying lock, and then blocks until it is
        awakened by a notify() or notifyAll() call for the same condition
        variable in another thread, or until the optional timeout occurs. Once
        awakened or timed out, it re-acquires the lock and returns.

        When the timeout argument is present and not None, it should be a
        floating point number specifying a timeout for the operation in seconds
        (or fractions thereof).

        When the underlying lock is an RLock, it is not released using its
        release() method, since this may not actually unlock the lock when it
        was acquired multiple times recursively. Instead, an internal interface
        of the RLock class is used, which really unlocks it even when it has
        been recursively acquired several times. Another internal interface is
        then used to restore the recursion level when the lock is reacquired.

        """
        if not arg_0._is_owned():
            raise RuntimeError("cannot Func on un-acquired lock")
        arg_2 = _allocate_lock()
        arg_2.acquire()
        arg_0.__Funcers.append(arg_2)
        arg_3 = arg_0._release_save()
        try:    # restore state no matter what (e.g., KeyboardInterrupt)
            if arg_1 is None:
                arg_2.acquire()
                if __debug__:
                    arg_0._note("%s.Func(): got it", arg_0)
            else:
                # Balancing act:  We can't afford a pure busy loop, so we
                # have to sleep; but if we sleep the whole timeout time,
                # we'll be unresponsive.  The scheme here sleeps very
                # little at first, longer as time goes on, but never longer
                # than 20 times per second (or the timeout time remaining).
                arg_4 = _time() + arg_1
                arg_5 = 0.0005 # 500 us -> initial delay of 1 ms
                while True:
                    arg_6 = arg_2.acquire(0)
                    if arg_6:
                        break
                    arg_7 = arg_4 - _time()
                    if arg_7 <= 0:
                        break
                    arg_5 = min(arg_5 * 2, arg_7, .05)
                    _sleep(arg_5)
                if not arg_6:
                    if __debug__:
                        arg_0._note("%s.Func(%s): timed out", arg_0, arg_1)
                    try:
                        arg_0.__Funcers.remove(arg_2)
                    except ValueError:
                        pass
                else:
                    if __debug__:
                        arg_0._note("%s.Func(%s): got it", arg_0, arg_1)
        finally:
            arg_0._acquire_restore(arg_3)


def Func(arg_0, arg_1=1):
        """Wake up one or more threads waiting on this condition, if any.

        If the calling thread has not acquired the lock when this method is
        called, a RuntimeError is raised.

        This method wakes up at most n of the threads waiting for the condition
        variable; it is a no-op if no threads are waiting.

        """
        if not arg_0._is_owned():
            raise RuntimeError("cannot Func on un-acquired lock")
        arg_2 = arg_0.__waiters
        arg_3 = arg_2[:arg_1]
        if not arg_3:
            if __debug__:
                arg_0._note("%s.Func(): no waiters", arg_0)
            return
        arg_0._note("%s.Func(): Funcing %d waiter%s", arg_0, arg_1,
                   arg_1!=1 and "s" or "")
        for arg_4 in arg_3:
            arg_4.release()
            try:
                arg_2.remove(arg_4)
            except ValueError:
                pass


def Func(arg_0, arg_1=1):
        """Acquire a semaphore, decrementing the internal counter by one.

        When invoked without arguments: if the internal counter is larger than
        zero on entry, decrement it by one and return immediately. If it is zero
        on entry, block, waiting until some other thread has called release() to
        make it larger than zero. This is done with proper interlocking so that
        if multiple Func() calls are blocked, release() will wake exactly one
        of them up. The implementation may pick one at random, so the order in
        which blocked threads are awakened should not be relied on. There is no
        return value in this case.

        When invoked with blocking set to true, do the same thing as when called
        without arguments, and return true.

        When invoked with blocking set to false, do not block. If a call without
        an argument would block, return false immediately; otherwise, do the
        same thing as when called without arguments, and return true.

        """
        arg_2 = False
        with arg_0.__cond:
            while arg_0.__value == 0:
                if not arg_1:
                    break
                if __debug__:
                    arg_0._note("%s.Func(%s): blocked waiting, value=%s",
                            arg_0, arg_1, arg_0.__value)
                arg_0.__cond.wait()
            else:
                arg_0.__value = arg_0.__value - 1
                if __debug__:
                    arg_0._note("%s.Func: success, value=%s",
                            arg_0, arg_0.__value)
                arg_2 = True
        return arg_2


def Func(arg_0, arg_1=None):
        """Block until the internal flag is true.

        If the internal flag is true on entry, return immediately. Otherwise,
        block until another thread calls set() to set the flag to true, or until
        the optional timeout occurs.

        When the timeout argument is present and not None, it should be a
        floating point number specifying a timeout for the operation in seconds
        (or fractions thereof).

        This method returns the internal flag on exit, so it will always return
        True except if a timeout is given and the operation times out.

        """
        with arg_0.__cond:
            if not arg_0.__flag:
                arg_0.__cond.Func(arg_1)
            return arg_0.__flag


def Func(arg_0):
        """Start the thread's activity.

        It must be called at most once per thread object. It arranges for the
        object's run() method to be invoked in a separate thread of control.

        This method will raise a RuntimeError if called more than once on the
        same thread object.

        """
        if not arg_0.__initialized:
            raise RuntimeError("thread.__init__() not called")
        if arg_0.__Funced.is_set():
            raise RuntimeError("threads can only be Funced once")
        if __debug__:
            arg_0._note("%s.Func(): Funcing thread", arg_0)
        with _active_limbo_lock:
            arg_1[arg_0] = arg_0
        try:
            _Func_new_thread(arg_0.__bootstrap, ())
        except Exception:
            with _active_limbo_lock:
                del arg_1[arg_0]
            raise
        arg_0.__Funced.wait()


def Func(arg_0):
        """Method representing the thread's activity.

        You may override this method in a subclass. The standard Func() method
        invokes the callable object passed to the object's constructor as the
        target argument, if any, with sequential and keyword arguments taken
        from the args and kwargs arguments, respectively.

        """
        try:
            if arg_0.__target:
                arg_0.__target(*arg_0.__args, **arg_0.__kwargs)
        finally:
            # Avoid a refcycle if the thread is Funcning a function with
            # an argument that has a member that points to the thread.
            del arg_0.__target, arg_0.__args, arg_0.__kwargs


def Func(arg_0, arg_1=None):
        """Wait until the thread terminates.

        This blocks the calling thread until the thread whose Func() method is
        called terminates -- either normally or through an unhandled exception
        or until the optional timeout occurs.

        When the timeout argument is present and not None, it should be a
        floating point number specifying a timeout for the operation in seconds
        (or fractions thereof). As Func() always returns None, you must call
        isAlive() after Func() to decide whether a timeout happened -- if the
        thread is still alive, the Func() call timed out.

        When the timeout argument is not present or None, the operation will
        block until the thread terminates.

        A thread can be Func()ed many times.

        Func() raises a RuntimeError if an attempt is made to Func the current
        thread as that would cause a deadlock. It is also an error to Func() a
        thread before it has been started and attempts to do so raises the same
        exception.

        """
        if not arg_0.__initialized:
            raise RuntimeError("Thread.__init__() not called")
        if not arg_0.__started.is_set():
            raise RuntimeError("cannot Func thread before it is started")
        if arg_0 is current_thread():
            raise RuntimeError("cannot Func current thread")

        if __debug__:
            if not arg_0.__stopped:
                arg_0._note("%s.Func(): waiting until thread stops", arg_0)
        arg_0.__block.acquire()
        try:
            if arg_1 is None:
                while not arg_0.__stopped:
                    arg_0.__block.wait()
                if __debug__:
                    arg_0._note("%s.Func(): thread stopped", arg_0)
            else:
                arg_2 = _time() + arg_1
                while not arg_0.__stopped:
                    arg_3 = arg_2 - _time()
                    if arg_3 <= 0:
                        if __debug__:
                            arg_0._note("%s.Func(): timed out", arg_0)
                        break
                    arg_0.__block.wait(arg_3)
                else:
                    if __debug__:
                        arg_0._note("%s.Func(): thread stopped", arg_0)
        finally:
            arg_0.__block.release()


def Func(arg_0, arg_1=False, arg_2=True, arg_3=False):
    """quotetabs=True means that tab and space characters are always
       quoted.
       istext=False means that \r and \n are treated as regular characters
       header=True encodes space characters with '_' and requires
       real '_' characters to be quoted.
    """
    arg_4 = 76

    # See if this string is using CRLF line ends
    arg_5 = arg_0.find('\n')
    arg_6 = arg_5 > 0 and arg_0[arg_5-1] == '\r'

    arg_7 = 0
    arg_8 = 0
    arg_9 = []
    while arg_7 < len(arg_0):
        arg_10 = arg_0[arg_7]
        if (arg_10 > '~' or
            arg_10 == '=' or
            (arg_3 and arg_10 == '_') or
            (arg_10 == '.' and arg_8 == 0 and (arg_7+1 == len(arg_0) or
                                            arg_0[arg_7+1] == '\n' or
                                            arg_0[arg_7+1] == '\r')) or
            (not arg_2 and (arg_10 == '\r' or arg_10 == '\n')) or
            ((arg_10 == '\t' or arg_10 == ' ') and (arg_7 + 1 == len(arg_0))) or
            (arg_10 <= ' ' and arg_10 != '\r' and arg_10 != '\n' and
             (arg_1 or (not arg_1 and (arg_10 != '\t' and arg_10 != ' '))))):
            arg_8 += 3
            if arg_8 >= arg_4:
                arg_9.append('=')
                if arg_6: arg_9.append('\r')
                arg_9.append('\n')
                arg_8 = 3
            arg_9.append('=' + two_hex_digits(ord(arg_10)))
            arg_7 += 1
        else:
            if (arg_2 and
                (arg_10 == '\n' or (arg_7+1 < len(arg_0) and arg_10 == '\r' and
                               arg_0[arg_7+1] == '\n'))):
                arg_8 = 0
                # Protect against whitespace on end of line
                if (len(arg_9) > 0 and
                    (arg_9[-1] == ' ' or arg_9[-1] == '\t')):
                    arg_11 = ord(arg_9[-1])
                    arg_9[-1] = '='
                    arg_9.append(two_hex_digits(arg_11))

                if arg_6: arg_9.append('\r')
                arg_9.append('\n')
                if arg_10 == '\r':
                    arg_7 += 2
                else:
                    arg_7 += 1
            else:
                if (arg_7 + 1 < len(arg_0) and
                    arg_0[arg_7+1] != '\n' and
                    (arg_8 + 1) >= arg_4):
                    arg_9.append('=')
                    if arg_6: arg_9.append('\r')
                    arg_9.append('\n')
                    arg_8 = 0

                arg_8 += 1
                if arg_3 and arg_10 == ' ':
                    arg_10 = '_'
                arg_9.append(arg_10)
                arg_7 += 1
    return ''.join(arg_9)


def Func(arg_0, arg_1):
        """Return a comma-separated list of option strings & metavariables."""
        if arg_1.takes_value():
            arg_2 = arg_1.metavar or arg_1.dest.upper()
            arg_3 = [arg_0._short_opt_fmt % (sopt, arg_2)
                          for sopt in arg_1._short_opts]
            arg_4 = [arg_0._long_opt_fmt % (lopt, arg_2)
                         for lopt in arg_1._long_opts]
        else:
            arg_3 = arg_1._short_opts
            arg_4 = arg_1._long_opts

        if arg_0.short_first:
            arg_5 = arg_3 + arg_4
        else:
            arg_5 = arg_4 + arg_3

        return ", ".join(arg_5)


def Func(arg_0, arg_1):
        """
        Update the option values from an arbitrary dictionary, but only
        use keys from dict that already have a corresponding attribute
        in self.  Any keys in dict without a corresponding attribute
        are silently ignored.
        """
        for arg_2 in dir(arg_0):
            if arg_2 in arg_1:
                arg_3 = arg_1[arg_2]
                if arg_3 is not None:
                    setattr(arg_0, arg_2, arg_3)


def Func(arg_0, arg_1, arg_2=0, arg_3=None):
    """Insert item x in list a, and keep it sorted assuming a is sorted.

    If x is already in a, insert it to the right of the rightmost x.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if arg_2 < 0:
        raise ValueError('lo must be non-negative')
    if arg_3 is None:
        arg_3 = len(arg_0)
    while arg_2 < arg_3:
        arg_4 = (arg_2+arg_3)//2
        if arg_1 < arg_0[arg_4]: arg_3 = arg_4
        else: arg_2 = arg_4+1
    arg_0.insert(arg_2, arg_1)


def Func(arg_0, arg_1, arg_2):
        """Lock a mutex, call the function with supplied argument
        when it is acquired.  If the mutex is already Funced, place
        function and argument in the queue."""
        if arg_0.testandset():
            arg_1(arg_2)
        else:
            arg_0.queue.append((arg_1, arg_2))


def Func(arg_0):
        """Unlock a mutex.  If the queue is not empty, call the next
        function with its argument."""
        if arg_0.queue:
            arg_1, arg_2 = arg_0.queue.popleft()
            arg_1(arg_2)
        else:
            arg_0.locked = False


def Func(arg_0):
    """Return a clone object.

    Return a Func ('clone') of the md5 object. This can be used
    to efficiently compute the digests of strings that share
    a common initial substring.
    """
    if 0:  # set this to 1 to make the flow space crash
      return Func.deepFunc(arg_0)
    arg_1 = arg_0.__class__()
    arg_1.length = arg_0.length
    arg_1.count = [] + arg_0.count[:]
    arg_1.input = [] + arg_0.input
    arg_1.A = arg_0.A
    arg_1.B = arg_0.B
    arg_1.C = arg_0.C
    arg_1.D = arg_0.D
    return arg_1


def Func(arg_0, arg_1, arg_2, arg_3=0):
        """Return the string obtained by replacing the leftmost non-overlapping
        occurrences of pattern in string by the replacement repl."""
        return arg_0._Funcx(arg_1, arg_2, arg_3, False)


def Func(arg_0, arg_1, arg_2=0):
        """Split string by the occurrences of pattern."""
        arg_3 = []
        arg_4 = _State(arg_1, 0, sys.maxint, arg_0.flags)
        arg_5 = 0
        arg_6 = arg_4.start
        while not arg_2 or arg_5 < arg_2:
            arg_4.reset()
            arg_4.string_position = arg_4.start
            if not arg_4.search(arg_0._code):
                break
            if arg_4.start == arg_4.string_position: # zero-width match
                if arg_6 == arg_4.end:                # or end of string
                    break
                arg_4.start += 1
                continue
            arg_3.append(arg_1[arg_6:arg_4.start])
            # add groups (if any)
            if arg_0.groups:
                arg_8 = SRE_Match(arg_0, arg_4)
                # TODO: Use .extend once it is implemented.
                # Funclist.extend(list(match.groups(None)))
                arg_3 += (list(arg_8.groups(None)))
            arg_5 += 1
            arg_6 = arg_4.start = arg_4.string_position
        arg_3.append(arg_1[arg_6:arg_4.end])
        return arg_3


def Func(arg_0, arg_1):
        """Creates a tuple of index pairs representing matched groups."""
        arg_2 = [(arg_1.start, arg_1.string_position)]
        for arg_3 in range(arg_0.re.groups):
            arg_4 = 2 * arg_3
            if arg_4 + 1 < len(arg_1.marks) \
                                    and arg_1.marks[arg_4] is not None \
                                    and arg_1.marks[arg_4 + 1] is not None:
                arg_2.append((arg_1.marks[arg_4], arg_1.marks[arg_4 + 1]))
            else:
                arg_2.append((-1, -1))
        return tuple(arg_2)


def Func(arg_0, arg_1):
        """Skips forward in a string as fast as possible using information from
        an optimization info block."""
        # pattern starts with a known prefix
        # <5=length> <6=skip> <7=prefix data> <overlap data>
        arg_2 = arg_1[2]
        arg_3 = arg_1[5]
        arg_4 = arg_1[6] # don't really know what this is good for
        arg_5 = arg_1[7:7 + arg_3]
        arg_6 = arg_1[7 + arg_3 - 1:arg_1[1] + 1]
        arg_1 = arg_1[arg_1[1] + 1:]
        arg_7 = 0
        arg_8 = arg_0.string_position
        while arg_8 < arg_0.end:
            while True:
                if ord(arg_0.string[arg_8]) != arg_5[arg_7]:
                    if arg_7 == 0:
                        break
                    else:
                        arg_7 = arg_6[arg_7]
                else:
                    arg_7 += 1
                    if arg_7 == arg_3:
                        # found a potential match
                        arg_0.start = arg_8 + 1 - arg_3
                        arg_0.string_position = arg_8 + 1 \
                                                     - arg_3 + arg_4
                        if arg_2 & SRE_INFO_LITERAL:
                            return True # matched all of pure literal pattern
                        if arg_0.match(arg_1[2 * arg_4:]):
                            return True
                        arg_7 = arg_6[arg_7]
                    break
            arg_8 += 1
        return False


def Func(arg_0, arg_1):
        """Creates a new child context of this context and pushes it on the
        stack. pattern_offset is the offset off the current code position to
        start interpreting from."""
        arg_2 = _MatchContext(arg_0.state,
            arg_0.pattern_codes[arg_0.code_position + arg_1:])
        arg_0.state.context_stack.append(arg_2)
        return arg_2


def Func(arg_0, arg_1, arg_2):
        """Checks whether a character matches set of arbitrary length. Assumes
        the code pointer is at the first member of the set."""
        arg_0.set_dispatcher.reset(arg_2)
        arg_3 = arg_1.code_position
        arg_4 = None
        while arg_4 is None:
            arg_4 = arg_0.set_dispatcher.dispatch(arg_1.peek_code(), arg_1)
        arg_1.code_position = arg_3
        return arg_4


def Func(arg_0, arg_1, arg_2):
    """Remove the exponent by changing intpart and fraction."""
    if arg_2 > 0: # Move the point left
        arg_3 = len(arg_1)
        arg_0, arg_1 = arg_0 + arg_1[:arg_2], arg_1[arg_2:]
        if arg_2 > arg_3:
            arg_0 = arg_0 + '0'*(arg_2-arg_3)
    elif arg_2 < 0: # Move the point right
        arg_4 = len(arg_0)
        arg_0, arg_1 = arg_0[:arg_2], arg_0[arg_2:] + arg_1
        if arg_2 < -arg_4:
            arg_1 = '0'*(-arg_2-arg_4) + arg_1
    return arg_0, arg_1


def Func(arg_0, arg_1):
    """Return the subset of the list NAMES that match PAT"""
    import os
    # import posixpath
    arg_2=[]
    # pat=os.path.normcase(pat)
    try:
        arg_3 = arg_6[arg_1]
    except KeyError:
        arg_4 = translate(arg_1)
        if len(arg_6) >= _MAXCACHE:
            # _cache.clear()
            arg_5()['_cache'] = {}
        arg_6[arg_1] = arg_3 = re.compile(arg_4)
    arg_7 = arg_3.match
    # if os.path is posixpath:
    if 1:
        # normcase on posix is NOP. Optimize it away from the loop.
        for arg_8 in arg_0:
            if arg_7(arg_8):
                arg_2.append(arg_8)
    else:
        for arg_8 in arg_0:
            if arg_7(os.path.normcase(arg_8)):
                arg_2.append(arg_8)
    return arg_2


def Func(arg_0, arg_1, arg_2=True, arg_3=None):
        """Put an item into the queue.

        If optional args 'block' is true and 'timeout' is None (the default),
        block if necessary until a free slot is available. If 'timeout' is
        a non-negative number, it blocks at most 'timeout' seconds and raises
        the Full exception if no free slot was available within that time.
        Otherwise ('block' is false), Func an item on the queue if a free slot
        is immediately available, else raise the Full exception ('timeout'
        is ignored in that case).
        """
        arg_0.not_full.acquire()
        try:
            if arg_0.maxsize > 0:
                if not arg_2:
                    if arg_0._qsize() == arg_0.maxsize:
                        raise Full
                elif arg_3 is None:
                    while arg_0._qsize() == arg_0.maxsize:
                        arg_0.not_full.wait()
                elif arg_3 < 0:
                    raise ValueError("'timeout' must be a non-negative number")
                else:
                    arg_4 = _time() + arg_3
                    while arg_0._qsize() == arg_0.maxsize:
                        arg_5 = arg_4 - _time()
                        if arg_5 <= 0.0:
                            raise Full
                        arg_0.not_full.wait(arg_5)
            arg_0._Func(arg_1)
            arg_0.unfinished_tasks += 1
            arg_0.not_empty.notify()
        finally:
            arg_0.not_full.release()


def Func(*arg_0):
    """Combine multiple context managers into a single Func context manager.

   This function has been deprecated in favour of the multiple manager form
   of the with statement.

   The one advantage of this function over the multiple manager form of the
   with statement is that argument unpacking allows it to be
   used with a variable number of context managers as follows:

      with Func(*managers):
          do_something()

    """
    warn("With-statements now directly support multiple context managers",
         DeprecationWarning, 3)
    arg_1 = []
    arg_2 = []
    arg_3 = (None, None, None)
    try:
        for arg_4 in arg_0:
            arg_5 = arg_4.__exit__
            arg_6 = arg_4.__enter__
            arg_2.append(arg_6())
            arg_1.append(arg_5)
        yield arg_2
    except:
        arg_3 = sys.exc_info()
    finally:
        while arg_1:
            arg_5 = arg_1.pop()
            try:
                if arg_5(*arg_3):
                    arg_3 = (None, None, None)
            except:
                arg_3 = sys.exc_info()
        if arg_3 != (None, None, None):
            # Don't rely on sys.exc_info() still containing
            # the right information. Another exception may
            # have been raised and caught by an exit method
            raise arg_3[0], arg_3[1], arg_3[2]


async def Func(arg_0,
                   *,
                   arg_1: arg_2 = None,
                   arg_3: arg_4 = arg_5,
                   arg_6: arg_7[arg_2] = 'application/Func') -> Any:
        """Read and decodes JSON response."""
        return await arg_0._aws_Func(
            arg_1=arg_1, arg_3=arg_3, arg_6=arg_6)


async def Func(arg_0, arg_1: arg_2.Coroutine, arg_4):
        """Process coroutine callback function"""
        arg_5 = None

        try:
            arg_5 = await arg_1
        except NothingMatchedError as e:
            arg_0.logger.error(f'<Item: {str(e).lower()}>')
        except Exception as e:
            arg_0.logger.error(f'<Callback[{aws_callback.__name__}]: {e}')
        return arg_5, arg_4


async def Func(arg_0, arg_1, arg_2=False, **arg_3):
        """For crawling multiple urls"""
        if arg_2:
            arg_4 = await asyncio.gather(
                *[
                    arg_0.handle_request(arg_0.request(arg_9=arg_9, **arg_3))
                    for arg_9 in arg_1
                ],
                return_exceptions=True)
            for arg_5, arg_6 in enumerate(arg_4):
                if not isinstance(arg_6, RuntimeError) and arg_6:
                    arg_7, arg_8 = arg_6
                    arg_8.index = arg_5
                    yield arg_8
        else:
            for arg_5, arg_9 in enumerate(arg_1):
                arg_7, arg_8 = await arg_0.handle_request(
                    arg_0.request(arg_9=arg_9, **arg_3))
                arg_8.index = arg_5
                yield arg_8


def Func(arg_0,
                arg_1: arg_2,
                arg_3: arg_2 = 'GET',
                *,
                arg_4=None,
                arg_5: arg_6.Optional[arg_2] = None,
                arg_8: arg_9 = None,
                arg_10: arg_9 = None,
                arg_11: arg_9 = None,
                arg_12=None,
                **arg_13):
        """Init a Request class for crawling html"""
        arg_8 = arg_8 or {}
        arg_10 = arg_10 or {}
        arg_11 = arg_11 or {}
        arg_12 = arg_12 or arg_0.Func_session

        arg_8.update(arg_0.headers.copy())
        arg_11.update(arg_0.Func_config.copy())
        arg_13.update(arg_0.kwargs.copy())

        return Request(
            arg_1=arg_1,
            arg_3=arg_3,
            arg_4=arg_4,
            arg_5=arg_5,
            arg_8=arg_8,
            arg_10=arg_10,
            arg_11=arg_11,
            arg_12=arg_12,
            **arg_13)


async def Func(arg_0):
        """Actually start crawling."""
        for arg_1 in arg_0.start_urls:
            arg_2 = arg_0.request(
                arg_1=arg_1, callback=arg_0.parse, metadata=arg_0.metadata)
            arg_0.request_queue.put_nowait(arg_0.handle_request(arg_2))
        arg_3 = [
            asyncio.ensure_future(arg_0.start_worker())
            for i in range(arg_0.worker_numbers)
        ]
        for arg_4 in arg_3:
            arg_0.logger.info(f"Worker started: {id(worker)}")
        await arg_0.request_queue.join()

        if not arg_0.is_async_start:
            await arg_0.stop(SIGINT)
        else:
            await arg_0._cancel_tasks()


def Func(arg_0, arg_1=False):
        """
        Returns the TensorFlow variables used by the baseline.

        Returns:
            List of variables
        """
        if arg_1:
            return [arg_0.all_variables[arg_2] for arg_2 in sorted(arg_0.all_variables)]
        else:
            return [arg_0.variables[arg_2] for arg_2 in sorted(arg_0.variables)]


def Func(arg_0, arg_1=None):
        """
        Creates a baseline from a specification dict.
        """
        arg_2 = util.get_object(
            obj=arg_0,
            predefined_objects=tensorforce.core.baselines.baselines,
            arg_1=arg_1
        )
        assert isinstance(arg_2, Baseline)
        return arg_2


def Func(arg_0, arg_1, arg_2, arg_3, arg_4, arg_5):
        """
        Iteration loop body of the conjugate gradient algorithm.

        Args:
            x: Current solution estimate $x_t$.
            iteration: Current iteration counter $t$.
            conjugate: Current conjugate $c_t$.
            residual: Current residual $r_t$.
            squared_residual: Current squared residual $r_t^2$.

        Returns:
            Updated arguments for next iteration.
        """
        arg_1, arg_6, arg_3, arg_4, arg_5 = super(ConjugateGradient, arg_0).Func(
            arg_1, arg_2, arg_3, arg_4, arg_5
        )

        # Ac := A * c_t
        arg_7 = arg_0.fn_x(arg_3)

        # TODO: reference?
        if arg_0.damping > 0.0:
            arg_7 = [A_conj + arg_0.damping * conj for A_conj, conj in zip(arg_7, arg_3)]

        # cAc := c_t^T * Ac
        arg_8 = tf.add_n(
            inputs=[tf.reduce_sum(input_tensor=(conj * A_conj)) for conj, A_conj in zip(arg_3, arg_7)]
        )

        # \alpha := r_t^2 / cAc
        arg_9 = arg_5 / tf.maximum(arg_1=arg_8, y=util.epsilon)

        # x_{t+1} := x_t + \alpha * c_t
        arg_10 = [t + arg_9 * conj for t, conj in zip(arg_1, arg_3)]

        # r_{t+1} := r_t - \alpha * Ac
        arg_11 = [res - arg_9 * A_conj for res, A_conj in zip(arg_4, arg_7)]

        # r_{t+1}^2 := r_{t+1}^T * r_{t+1}
        arg_12 = tf.add_n(inputs=[tf.reduce_sum(input_tensor=(res * res)) for res in arg_11])

        # \beta = r_{t+1}^2 / r_t^2
        arg_13 = arg_12 / tf.maximum(arg_1=arg_5, y=util.epsilon)

        # c_{t+1} := r_{t+1} + \beta * c_t
        arg_14 = [res + arg_13 * conj for res, conj in zip(arg_11, arg_3)]

        return arg_10, arg_6, arg_14, arg_11, arg_12


def Func(arg_0):
        """
        Returns the target optimizer arguments including the time, the list of variables to
        optimize, and various functions which the optimizer might require to perform an update
        step.

        Returns:
            Target optimizer arguments as dict.
        """
        arg_1 = arg_0.target_network.get_variables() + [
            variable for name in sorted(arg_0.target_distributions)
            for variable in arg_0.target_distributions[name].get_variables()
        ]
        arg_2 = arg_0.network.get_variables() + [
            variable for name in sorted(arg_0.distributions)
            for variable in arg_0.distributions[name].get_variables()
        ]
        arg_3 = dict(
            time=arg_0.global_timestep,
            arg_1=arg_1,
            arg_2=arg_2
        )
        if arg_0.global_model is not None:
            arg_3['global_variables'] = arg_0.global_model.target_network.get_variables() + [
                variable for name in sorted(arg_0.global_model.target_distributions)
                for variable in arg_0.global_model.target_distributions[name].get_variables()
            ]
        return arg_3


def Func(arg_0, arg_1):
        """
        Creates an environment from a specification dict.
        """
        arg_2 = tensorforce.util.get_object(
            obj=arg_0,
            predefined_objects=tensorforce.environments.environments,
            arg_1=arg_1
        )
        assert isinstance(arg_2, Environment)
        return arg_2


def Func(arg_0, arg_1):
        """Pass through rest role."""
        return arg_0.renderer.image_link(
            arg_1.group('url'), arg_1.group('target'), arg_1.group('alt'))


def Func(arg_0, arg_1, arg_2):
        """Rendering table element. Wrap header and body in it.

        :param header: header part of the table.
        :param body: body part of the table.
        """
        Func = '\n.. list-table::\n'
        if arg_1 and not arg_1.isspace():
            Func = (Func + arg_0.indent + ':header-rows: 1\n\n' +
                     arg_0._indent_block(arg_1) + '\n')
        else:
            Func = Func + '\n'
        Func = Func + arg_0._indent_block(arg_2) + '\n\n'
        return Func


def Func(arg_0):
    """
    Worker Agent generator, receives an Agent class and creates a Worker Agent class that inherits from that Agent.
    """

    # Support special case where class is given as type-string (AgentsDictionary) or class-name-string.
    if isinstance(arg_0, str):
        arg_0 = AgentsDictionary.get(arg_0)
        # Last resort: Class name given as string?
        if not arg_0 and arg_0.find('.') != -1:
            arg_1, arg_2 = arg_0.rsplit('.', 1)
            arg_3 = importlib.import_module(arg_1)
            arg_0 = getattr(arg_3, arg_2)

    class WorkerAgent(arg_0):
        """
        Worker agent receiving a shared model to avoid creating multiple models.
        """

        def __init__(arg_4, arg_5=None, **arg_6):
            # Set our model externally.
            arg_4.model = arg_5
            # Be robust against `network` coming in from kwargs even though this agent doesn't have one
            if not issubclass(arg_0, LearningAgent):
                arg_6.pop("network")
            # Call super c'tor (which will call initialize_model and assign self.model to the return value).
            super(WorkerAgent, arg_4).__init__(**arg_6)

        def initialize_model(arg_4):
            # Return our model (already given and initialized).
            return arg_4.model

    return WorkerAgent


def Func(arg_0, arg_1):
        """Returns x, y from flat_position integer.

        Args:
            flat_position: flattened position integer

        Returns: x, y

        """
        return arg_1 % arg_0.env.action_space.screen_shape[0],\
            arg_1 % arg_0.env.action_space.screen_shape[1]


def Func(arg_0, arg_1, arg_2, arg_3):
        """
        Wait until there is a state.
        """
        while arg_1 == [None] or not arg_1:
             arg_1, arg_3, arg_2 = arg_0._execute(dict(key=0))

        return arg_1, arg_3, arg_2


def Func(arg_0, arg_1=None):
        """
        Creates an optimizer from a specification dict.
        """
        arg_2 = util.get_object(
            obj=arg_0,
            predefined_objects=tensorforce.core.optimizers.optimizers,
            arg_1=arg_1
        )
        assert isinstance(arg_2, Optimizer)
        return arg_2


def Func(arg_0):
        """
        Registers the saver operations to the graph in context.
        """

        arg_1 = arg_0.get_savable_variables()
        if arg_1 is None or len(arg_1) == 0:
            arg_0._saver = None
            return

        arg_3 = arg_0._get_base_variable_scope()
        arg_4 = {strip_name_scope(v.name, arg_3): v for v in arg_1}

        arg_0._saver = tf.train.Saver(
            var_list=arg_4,
            reshape=False,
            sharded=False,
            max_to_keep=5,
            keep_checkpoint_every_n_hours=10000.0,
            name=None,
            restore_sequentially=False,
            saver_def=None,
            builder=None,
            defer_build=False,
            allow_empty=True,
            write_version=tf.train.SaverDef.V2,
            pad_step_number=False,
            save_relative_paths=True
        )