HEX
Server: Apache
System: Linux vmi318001.contaboserver.net 6.8.0-117-generic #117-Ubuntu SMP PREEMPT_DYNAMIC Tue May 5 19:26:24 UTC 2026 x86_64
User: boxelikax (1004)
PHP: 8.2.33
Disabled: NONE
Upload Files
File: /home/boxelikax/public_html/demoltec.com/re.zip
PKV*]�[����
_parser.pynu�[���#
# Secret Labs' Regular Expression Engine
#
# convert re-style regular expression to sre pattern
#
# Copyright (c) 1998-2001 by Secret Labs AB.  All rights reserved.
#
# See the __init__.py file for information on usage and redistribution.
#

"""Internal support module for sre"""

# XXX: show string offset and offending character for all errors

from ._constants import *

SPECIAL_CHARS = ".\\[{()*+?^$|"
REPEAT_CHARS = "*+?{"

DIGITS = frozenset("0123456789")

OCTDIGITS = frozenset("01234567")
HEXDIGITS = frozenset("0123456789abcdefABCDEF")
ASCIILETTERS = frozenset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

WHITESPACE = frozenset(" \t\n\r\v\f")

_REPEATCODES = frozenset({MIN_REPEAT, MAX_REPEAT, POSSESSIVE_REPEAT})
_UNITCODES = frozenset({ANY, RANGE, IN, LITERAL, NOT_LITERAL, CATEGORY})

ESCAPES = {
    r"\a": (LITERAL, ord("\a")),
    r"\b": (LITERAL, ord("\b")),
    r"\f": (LITERAL, ord("\f")),
    r"\n": (LITERAL, ord("\n")),
    r"\r": (LITERAL, ord("\r")),
    r"\t": (LITERAL, ord("\t")),
    r"\v": (LITERAL, ord("\v")),
    r"\\": (LITERAL, ord("\\"))
}

CATEGORIES = {
    r"\A": (AT, AT_BEGINNING_STRING), # start of string
    r"\b": (AT, AT_BOUNDARY),
    r"\B": (AT, AT_NON_BOUNDARY),
    r"\d": (IN, [(CATEGORY, CATEGORY_DIGIT)]),
    r"\D": (IN, [(CATEGORY, CATEGORY_NOT_DIGIT)]),
    r"\s": (IN, [(CATEGORY, CATEGORY_SPACE)]),
    r"\S": (IN, [(CATEGORY, CATEGORY_NOT_SPACE)]),
    r"\w": (IN, [(CATEGORY, CATEGORY_WORD)]),
    r"\W": (IN, [(CATEGORY, CATEGORY_NOT_WORD)]),
    r"\Z": (AT, AT_END_STRING), # end of string
}

FLAGS = {
    # standard flags
    "i": SRE_FLAG_IGNORECASE,
    "L": SRE_FLAG_LOCALE,
    "m": SRE_FLAG_MULTILINE,
    "s": SRE_FLAG_DOTALL,
    "x": SRE_FLAG_VERBOSE,
    # extensions
    "a": SRE_FLAG_ASCII,
    "t": SRE_FLAG_TEMPLATE,
    "u": SRE_FLAG_UNICODE,
}

TYPE_FLAGS = SRE_FLAG_ASCII | SRE_FLAG_LOCALE | SRE_FLAG_UNICODE
GLOBAL_FLAGS = SRE_FLAG_DEBUG | SRE_FLAG_TEMPLATE

# Maximal value returned by SubPattern.getwidth().
# Must be larger than MAXREPEAT, MAXCODE and sys.maxsize.
MAXWIDTH = 1 << 64

class State:
    # keeps track of state for parsing
    def __init__(self):
        self.flags = 0
        self.groupdict = {}
        self.groupwidths = [None]  # group 0
        self.lookbehindgroups = None
        self.grouprefpos = {}
    @property
    def groups(self):
        return len(self.groupwidths)
    def opengroup(self, name=None):
        gid = self.groups
        self.groupwidths.append(None)
        if self.groups > MAXGROUPS:
            raise error("too many groups")
        if name is not None:
            ogid = self.groupdict.get(name, None)
            if ogid is not None:
                raise error("redefinition of group name %r as group %d; "
                            "was group %d" % (name, gid,  ogid))
            self.groupdict[name] = gid
        return gid
    def closegroup(self, gid, p):
        self.groupwidths[gid] = p.getwidth()
    def checkgroup(self, gid):
        return gid < self.groups and self.groupwidths[gid] is not None

    def checklookbehindgroup(self, gid, source):
        if self.lookbehindgroups is not None:
            if not self.checkgroup(gid):
                raise source.error('cannot refer to an open group')
            if gid >= self.lookbehindgroups:
                raise source.error('cannot refer to group defined in the same '
                                   'lookbehind subpattern')

class SubPattern:
    # a subpattern, in intermediate form
    def __init__(self, state, data=None):
        self.state = state
        if data is None:
            data = []
        self.data = data
        self.width = None

    def dump(self, level=0):
        seqtypes = (tuple, list)
        for op, av in self.data:
            print(level*"  " + str(op), end='')
            if op is IN:
                # member sublanguage
                print()
                for op, a in av:
                    print((level+1)*"  " + str(op), a)
            elif op is BRANCH:
                print()
                for i, a in enumerate(av[1]):
                    if i:
                        print(level*"  " + "OR")
                    a.dump(level+1)
            elif op is GROUPREF_EXISTS:
                condgroup, item_yes, item_no = av
                print('', condgroup)
                item_yes.dump(level+1)
                if item_no:
                    print(level*"  " + "ELSE")
                    item_no.dump(level+1)
            elif isinstance(av, SubPattern):
                print()
                av.dump(level+1)
            elif isinstance(av, seqtypes):
                nl = False
                for a in av:
                    if isinstance(a, SubPattern):
                        if not nl:
                            print()
                        a.dump(level+1)
                        nl = True
                    else:
                        if not nl:
                            print(' ', end='')
                        print(a, end='')
                        nl = False
                if not nl:
                    print()
            else:
                print('', av)
    def __repr__(self):
        return repr(self.data)
    def __len__(self):
        return len(self.data)
    def __delitem__(self, index):
        del self.data[index]
    def __getitem__(self, index):
        if isinstance(index, slice):
            return SubPattern(self.state, self.data[index])
        return self.data[index]
    def __setitem__(self, index, code):
        self.data[index] = code
    def insert(self, index, code):
        self.data.insert(index, code)
    def append(self, code):
        self.data.append(code)
    def getwidth(self):
        # determine the width (min, max) for this subpattern
        if self.width is not None:
            return self.width
        lo = hi = 0
        for op, av in self.data:
            if op is BRANCH:
                i = MAXWIDTH
                j = 0
                for av in av[1]:
                    l, h = av.getwidth()
                    i = min(i, l)
                    j = max(j, h)
                lo = lo + i
                hi = hi + j
            elif op is ATOMIC_GROUP:
                i, j = av.getwidth()
                lo = lo + i
                hi = hi + j
            elif op is SUBPATTERN:
                i, j = av[-1].getwidth()
                lo = lo + i
                hi = hi + j
            elif op in _REPEATCODES:
                i, j = av[2].getwidth()
                lo = lo + i * av[0]
                if av[1] == MAXREPEAT and j:
                    hi = MAXWIDTH
                else:
                    hi = hi + j * av[1]
            elif op in _UNITCODES:
                lo = lo + 1
                hi = hi + 1
            elif op is GROUPREF:
                i, j = self.state.groupwidths[av]
                lo = lo + i
                hi = hi + j
            elif op is GROUPREF_EXISTS:
                i, j = av[1].getwidth()
                if av[2] is not None:
                    l, h = av[2].getwidth()
                    i = min(i, l)
                    j = max(j, h)
                else:
                    i = 0
                lo = lo + i
                hi = hi + j
            elif op is SUCCESS:
                break
        self.width = min(lo, MAXWIDTH), min(hi, MAXWIDTH)
        return self.width

class Tokenizer:
    def __init__(self, string):
        self.istext = isinstance(string, str)
        self.string = string
        if not self.istext:
            string = str(string, 'latin1')
        self.decoded_string = string
        self.index = 0
        self.next = None
        self.__next()
    def __next(self):
        index = self.index
        try:
            char = self.decoded_string[index]
        except IndexError:
            self.next = None
            return
        if char == "\\":
            index += 1
            try:
                char += self.decoded_string[index]
            except IndexError:
                raise error("bad escape (end of pattern)",
                            self.string, len(self.string) - 1) from None
        self.index = index + 1
        self.next = char
    def match(self, char):
        if char == self.next:
            self.__next()
            return True
        return False
    def get(self):
        this = self.next
        self.__next()
        return this
    def getwhile(self, n, charset):
        result = ''
        for _ in range(n):
            c = self.next
            if c not in charset:
                break
            result += c
            self.__next()
        return result
    def getuntil(self, terminator, name):
        result = ''
        while True:
            c = self.next
            self.__next()
            if c is None:
                if not result:
                    raise self.error("missing " + name)
                raise self.error("missing %s, unterminated name" % terminator,
                                 len(result))
            if c == terminator:
                if not result:
                    raise self.error("missing " + name, 1)
                break
            result += c
        return result
    @property
    def pos(self):
        return self.index - len(self.next or '')
    def tell(self):
        return self.index - len(self.next or '')
    def seek(self, index):
        self.index = index
        self.__next()

    def error(self, msg, offset=0):
        if not self.istext:
            msg = msg.encode('ascii', 'backslashreplace').decode('ascii')
        return error(msg, self.string, self.tell() - offset)

    def checkgroupname(self, name, offset, nested):
        if not name.isidentifier():
            msg = "bad character in group name %r" % name
            raise self.error(msg, len(name) + offset)
        if not (self.istext or name.isascii()):
            import warnings
            warnings.warn(
                "bad character in group name %a at position %d" %
                (name, self.tell() - len(name) - offset),
                DeprecationWarning, stacklevel=nested + 7
            )

def _class_escape(source, escape):
    # handle escape code inside character class
    code = ESCAPES.get(escape)
    if code:
        return code
    code = CATEGORIES.get(escape)
    if code and code[0] is IN:
        return code
    try:
        c = escape[1:2]
        if c == "x":
            # hexadecimal escape (exactly two digits)
            escape += source.getwhile(2, HEXDIGITS)
            if len(escape) != 4:
                raise source.error("incomplete escape %s" % escape, len(escape))
            return LITERAL, int(escape[2:], 16)
        elif c == "u" and source.istext:
            # unicode escape (exactly four digits)
            escape += source.getwhile(4, HEXDIGITS)
            if len(escape) != 6:
                raise source.error("incomplete escape %s" % escape, len(escape))
            return LITERAL, int(escape[2:], 16)
        elif c == "U" and source.istext:
            # unicode escape (exactly eight digits)
            escape += source.getwhile(8, HEXDIGITS)
            if len(escape) != 10:
                raise source.error("incomplete escape %s" % escape, len(escape))
            c = int(escape[2:], 16)
            chr(c) # raise ValueError for invalid code
            return LITERAL, c
        elif c == "N" and source.istext:
            import unicodedata
            # named unicode escape e.g. \N{EM DASH}
            if not source.match('{'):
                raise source.error("missing {")
            charname = source.getuntil('}', 'character name')
            try:
                c = ord(unicodedata.lookup(charname))
            except (KeyError, TypeError):
                raise source.error("undefined character name %r" % charname,
                                   len(charname) + len(r'\N{}')) from None
            return LITERAL, c
        elif c in OCTDIGITS:
            # octal escape (up to three digits)
            escape += source.getwhile(2, OCTDIGITS)
            c = int(escape[1:], 8)
            if c > 0o377:
                raise source.error('octal escape value %s outside of '
                                   'range 0-0o377' % escape, len(escape))
            return LITERAL, c
        elif c in DIGITS:
            raise ValueError
        if len(escape) == 2:
            if c in ASCIILETTERS:
                raise source.error('bad escape %s' % escape, len(escape))
            return LITERAL, ord(escape[1])
    except ValueError:
        pass
    raise source.error("bad escape %s" % escape, len(escape))

def _escape(source, escape, state):
    # handle escape code in expression
    code = CATEGORIES.get(escape)
    if code:
        return code
    code = ESCAPES.get(escape)
    if code:
        return code
    try:
        c = escape[1:2]
        if c == "x":
            # hexadecimal escape
            escape += source.getwhile(2, HEXDIGITS)
            if len(escape) != 4:
                raise source.error("incomplete escape %s" % escape, len(escape))
            return LITERAL, int(escape[2:], 16)
        elif c == "u" and source.istext:
            # unicode escape (exactly four digits)
            escape += source.getwhile(4, HEXDIGITS)
            if len(escape) != 6:
                raise source.error("incomplete escape %s" % escape, len(escape))
            return LITERAL, int(escape[2:], 16)
        elif c == "U" and source.istext:
            # unicode escape (exactly eight digits)
            escape += source.getwhile(8, HEXDIGITS)
            if len(escape) != 10:
                raise source.error("incomplete escape %s" % escape, len(escape))
            c = int(escape[2:], 16)
            chr(c) # raise ValueError for invalid code
            return LITERAL, c
        elif c == "N" and source.istext:
            import unicodedata
            # named unicode escape e.g. \N{EM DASH}
            if not source.match('{'):
                raise source.error("missing {")
            charname = source.getuntil('}', 'character name')
            try:
                c = ord(unicodedata.lookup(charname))
            except (KeyError, TypeError):
                raise source.error("undefined character name %r" % charname,
                                   len(charname) + len(r'\N{}')) from None
            return LITERAL, c
        elif c == "0":
            # octal escape
            escape += source.getwhile(2, OCTDIGITS)
            return LITERAL, int(escape[1:], 8)
        elif c in DIGITS:
            # octal escape *or* decimal group reference (sigh)
            if source.next in DIGITS:
                escape += source.get()
                if (escape[1] in OCTDIGITS and escape[2] in OCTDIGITS and
                    source.next in OCTDIGITS):
                    # got three octal digits; this is an octal escape
                    escape += source.get()
                    c = int(escape[1:], 8)
                    if c > 0o377:
                        raise source.error('octal escape value %s outside of '
                                           'range 0-0o377' % escape,
                                           len(escape))
                    return LITERAL, c
            # not an octal escape, so this is a group reference
            group = int(escape[1:])
            if group < state.groups:
                if not state.checkgroup(group):
                    raise source.error("cannot refer to an open group",
                                       len(escape))
                state.checklookbehindgroup(group, source)
                return GROUPREF, group
            raise source.error("invalid group reference %d" % group, len(escape) - 1)
        if len(escape) == 2:
            if c in ASCIILETTERS:
                raise source.error("bad escape %s" % escape, len(escape))
            return LITERAL, ord(escape[1])
    except ValueError:
        pass
    raise source.error("bad escape %s" % escape, len(escape))

def _uniq(items):
    return list(dict.fromkeys(items))

def _parse_sub(source, state, verbose, nested):
    # parse an alternation: a|b|c

    items = []
    itemsappend = items.append
    sourcematch = source.match
    start = source.tell()
    while True:
        itemsappend(_parse(source, state, verbose, nested + 1,
                           not nested and not items))
        if not sourcematch("|"):
            break
        if not nested:
            verbose = state.flags & SRE_FLAG_VERBOSE

    if len(items) == 1:
        return items[0]

    subpattern = SubPattern(state)

    # check if all items share a common prefix
    while True:
        prefix = None
        for item in items:
            if not item:
                break
            if prefix is None:
                prefix = item[0]
            elif item[0] != prefix:
                break
        else:
            # all subitems start with a common "prefix".
            # move it out of the branch
            for item in items:
                del item[0]
            subpattern.append(prefix)
            continue # check next one
        break

    # check if the branch can be replaced by a character set
    set = []
    for item in items:
        if len(item) != 1:
            break
        op, av = item[0]
        if op is LITERAL:
            set.append((op, av))
        elif op is IN and av[0][0] is not NEGATE:
            set.extend(av)
        else:
            break
    else:
        # we can store this as a character set instead of a
        # branch (the compiler may optimize this even more)
        subpattern.append((IN, _uniq(set)))
        return subpattern

    subpattern.append((BRANCH, (None, items)))
    return subpattern

def _parse(source, state, verbose, nested, first=False):
    # parse a simple pattern
    subpattern = SubPattern(state)

    # precompute constants into local variables
    subpatternappend = subpattern.append
    sourceget = source.get
    sourcematch = source.match
    _len = len
    _ord = ord

    while True:

        this = source.next
        if this is None:
            break # end of pattern
        if this in "|)":
            break # end of subpattern
        sourceget()

        if verbose:
            # skip whitespace and comments
            if this in WHITESPACE:
                continue
            if this == "#":
                while True:
                    this = sourceget()
                    if this is None or this == "\n":
                        break
                continue

        if this[0] == "\\":
            code = _escape(source, this, state)
            subpatternappend(code)

        elif this not in SPECIAL_CHARS:
            subpatternappend((LITERAL, _ord(this)))

        elif this == "[":
            here = source.tell() - 1
            # character set
            set = []
            setappend = set.append
##          if sourcematch(":"):
##              pass # handle character classes
            if source.next == '[':
                import warnings
                warnings.warn(
                    'Possible nested set at position %d' % source.tell(),
                    FutureWarning, stacklevel=nested + 6
                )
            negate = sourcematch("^")
            # check remaining characters
            while True:
                this = sourceget()
                if this is None:
                    raise source.error("unterminated character set",
                                       source.tell() - here)
                if this == "]" and set:
                    break
                elif this[0] == "\\":
                    code1 = _class_escape(source, this)
                else:
                    if set and this in '-&~|' and source.next == this:
                        import warnings
                        warnings.warn(
                            'Possible set %s at position %d' % (
                                'difference' if this == '-' else
                                'intersection' if this == '&' else
                                'symmetric difference' if this == '~' else
                                'union',
                                source.tell() - 1),
                            FutureWarning, stacklevel=nested + 6
                        )
                    code1 = LITERAL, _ord(this)
                if sourcematch("-"):
                    # potential range
                    that = sourceget()
                    if that is None:
                        raise source.error("unterminated character set",
                                           source.tell() - here)
                    if that == "]":
                        if code1[0] is IN:
                            code1 = code1[1][0]
                        setappend(code1)
                        setappend((LITERAL, _ord("-")))
                        break
                    if that[0] == "\\":
                        code2 = _class_escape(source, that)
                    else:
                        if that == '-':
                            import warnings
                            warnings.warn(
                                'Possible set difference at position %d' % (
                                    source.tell() - 2),
                                FutureWarning, stacklevel=nested + 6
                            )
                        code2 = LITERAL, _ord(that)
                    if code1[0] != LITERAL or code2[0] != LITERAL:
                        msg = "bad character range %s-%s" % (this, that)
                        raise source.error(msg, len(this) + 1 + len(that))
                    lo = code1[1]
                    hi = code2[1]
                    if hi < lo:
                        msg = "bad character range %s-%s" % (this, that)
                        raise source.error(msg, len(this) + 1 + len(that))
                    setappend((RANGE, (lo, hi)))
                else:
                    if code1[0] is IN:
                        code1 = code1[1][0]
                    setappend(code1)

            set = _uniq(set)
            # XXX: <fl> should move set optimization to compiler!
            if _len(set) == 1 and set[0][0] is LITERAL:
                # optimization
                if negate:
                    subpatternappend((NOT_LITERAL, set[0][1]))
                else:
                    subpatternappend(set[0])
            else:
                if negate:
                    set.insert(0, (NEGATE, None))
                # charmap optimization can't be added here because
                # global flags still are not known
                subpatternappend((IN, set))

        elif this in REPEAT_CHARS:
            # repeat previous item
            here = source.tell()
            if this == "?":
                min, max = 0, 1
            elif this == "*":
                min, max = 0, MAXREPEAT

            elif this == "+":
                min, max = 1, MAXREPEAT
            elif this == "{":
                if source.next == "}":
                    subpatternappend((LITERAL, _ord(this)))
                    continue

                min, max = 0, MAXREPEAT
                lo = hi = ""
                while source.next in DIGITS:
                    lo += sourceget()
                if sourcematch(","):
                    while source.next in DIGITS:
                        hi += sourceget()
                else:
                    hi = lo
                if not sourcematch("}"):
                    subpatternappend((LITERAL, _ord(this)))
                    source.seek(here)
                    continue

                if lo:
                    min = int(lo)
                    if min >= MAXREPEAT:
                        raise OverflowError("the repetition number is too large")
                if hi:
                    max = int(hi)
                    if max >= MAXREPEAT:
                        raise OverflowError("the repetition number is too large")
                    if max < min:
                        raise source.error("min repeat greater than max repeat",
                                           source.tell() - here)
            else:
                raise AssertionError("unsupported quantifier %r" % (char,))
            # figure out which item to repeat
            if subpattern:
                item = subpattern[-1:]
            else:
                item = None
            if not item or item[0][0] is AT:
                raise source.error("nothing to repeat",
                                   source.tell() - here + len(this))
            if item[0][0] in _REPEATCODES:
                raise source.error("multiple repeat",
                                   source.tell() - here + len(this))
            if item[0][0] is SUBPATTERN:
                group, add_flags, del_flags, p = item[0][1]
                if group is None and not add_flags and not del_flags:
                    item = p
            if sourcematch("?"):
                # Non-Greedy Match
                subpattern[-1] = (MIN_REPEAT, (min, max, item))
            elif sourcematch("+"):
                # Possessive Match (Always Greedy)
                subpattern[-1] = (POSSESSIVE_REPEAT, (min, max, item))
            else:
                # Greedy Match
                subpattern[-1] = (MAX_REPEAT, (min, max, item))

        elif this == ".":
            subpatternappend((ANY, None))

        elif this == "(":
            start = source.tell() - 1
            capture = True
            atomic = False
            name = None
            add_flags = 0
            del_flags = 0
            if sourcematch("?"):
                # options
                char = sourceget()
                if char is None:
                    raise source.error("unexpected end of pattern")
                if char == "P":
                    # python extensions
                    if sourcematch("<"):
                        # named group: skip forward to end of name
                        name = source.getuntil(">", "group name")
                        source.checkgroupname(name, 1, nested)
                    elif sourcematch("="):
                        # named backreference
                        name = source.getuntil(")", "group name")
                        source.checkgroupname(name, 1, nested)
                        gid = state.groupdict.get(name)
                        if gid is None:
                            msg = "unknown group name %r" % name
                            raise source.error(msg, len(name) + 1)
                        if not state.checkgroup(gid):
                            raise source.error("cannot refer to an open group",
                                               len(name) + 1)
                        state.checklookbehindgroup(gid, source)
                        subpatternappend((GROUPREF, gid))
                        continue

                    else:
                        char = sourceget()
                        if char is None:
                            raise source.error("unexpected end of pattern")
                        raise source.error("unknown extension ?P" + char,
                                           len(char) + 2)
                elif char == ":":
                    # non-capturing group
                    capture = False
                elif char == "#":
                    # comment
                    while True:
                        if source.next is None:
                            raise source.error("missing ), unterminated comment",
                                               source.tell() - start)
                        if sourceget() == ")":
                            break
                    continue

                elif char in "=!<":
                    # lookahead assertions
                    dir = 1
                    if char == "<":
                        char = sourceget()
                        if char is None:
                            raise source.error("unexpected end of pattern")
                        if char not in "=!":
                            raise source.error("unknown extension ?<" + char,
                                               len(char) + 2)
                        dir = -1 # lookbehind
                        lookbehindgroups = state.lookbehindgroups
                        if lookbehindgroups is None:
                            state.lookbehindgroups = state.groups
                    p = _parse_sub(source, state, verbose, nested + 1)
                    if dir < 0:
                        if lookbehindgroups is None:
                            state.lookbehindgroups = None
                    if not sourcematch(")"):
                        raise source.error("missing ), unterminated subpattern",
                                           source.tell() - start)
                    if char == "=":
                        subpatternappend((ASSERT, (dir, p)))
                    else:
                        subpatternappend((ASSERT_NOT, (dir, p)))
                    continue

                elif char == "(":
                    # conditional backreference group
                    condname = source.getuntil(")", "group name")
                    if condname.isidentifier():
                        source.checkgroupname(condname, 1, nested)
                        condgroup = state.groupdict.get(condname)
                        if condgroup is None:
                            msg = "unknown group name %r" % condname
                            raise source.error(msg, len(condname) + 1)
                    else:
                        try:
                            condgroup = int(condname)
                            if condgroup < 0:
                                raise ValueError
                        except ValueError:
                            msg = "bad character in group name %r" % condname
                            raise source.error(msg, len(condname) + 1) from None
                        if not condgroup:
                            raise source.error("bad group number",
                                               len(condname) + 1)
                        if condgroup >= MAXGROUPS:
                            msg = "invalid group reference %d" % condgroup
                            raise source.error(msg, len(condname) + 1)
                        if condgroup not in state.grouprefpos:
                            state.grouprefpos[condgroup] = (
                                source.tell() - len(condname) - 1
                            )
                        if not (condname.isdecimal() and condname.isascii()):
                            import warnings
                            warnings.warn(
                                "bad character in group name %s at position %d" %
                                (repr(condname) if source.istext else ascii(condname),
                                 source.tell() - len(condname) - 1),
                                DeprecationWarning, stacklevel=nested + 6
                            )
                    state.checklookbehindgroup(condgroup, source)
                    item_yes = _parse(source, state, verbose, nested + 1)
                    if source.match("|"):
                        item_no = _parse(source, state, verbose, nested + 1)
                        if source.next == "|":
                            raise source.error("conditional backref with more than two branches")
                    else:
                        item_no = None
                    if not source.match(")"):
                        raise source.error("missing ), unterminated subpattern",
                                           source.tell() - start)
                    subpatternappend((GROUPREF_EXISTS, (condgroup, item_yes, item_no)))
                    continue

                elif char == ">":
                    # non-capturing, atomic group
                    capture = False
                    atomic = True
                elif char in FLAGS or char == "-":
                    # flags
                    flags = _parse_flags(source, state, char)
                    if flags is None:  # global flags
                        if not first or subpattern:
                            raise source.error('global flags not at the start '
                                               'of the expression',
                                               source.tell() - start)
                        verbose = state.flags & SRE_FLAG_VERBOSE
                        continue

                    add_flags, del_flags = flags
                    capture = False
                else:
                    raise source.error("unknown extension ?" + char,
                                       len(char) + 1)

            # parse group contents
            if capture:
                try:
                    group = state.opengroup(name)
                except error as err:
                    raise source.error(err.msg, len(name) + 1) from None
            else:
                group = None
            sub_verbose = ((verbose or (add_flags & SRE_FLAG_VERBOSE)) and
                           not (del_flags & SRE_FLAG_VERBOSE))
            p = _parse_sub(source, state, sub_verbose, nested + 1)
            if not source.match(")"):
                raise source.error("missing ), unterminated subpattern",
                                   source.tell() - start)
            if group is not None:
                state.closegroup(group, p)
            if atomic:
                assert group is None
                subpatternappend((ATOMIC_GROUP, p))
            else:
                subpatternappend((SUBPATTERN, (group, add_flags, del_flags, p)))

        elif this == "^":
            subpatternappend((AT, AT_BEGINNING))

        elif this == "$":
            subpatternappend((AT, AT_END))

        else:
            raise AssertionError("unsupported special character %r" % (char,))

    # unpack non-capturing groups
    for i in range(len(subpattern))[::-1]:
        op, av = subpattern[i]
        if op is SUBPATTERN:
            group, add_flags, del_flags, p = av
            if group is None and not add_flags and not del_flags:
                subpattern[i: i+1] = p

    return subpattern

def _parse_flags(source, state, char):
    sourceget = source.get
    add_flags = 0
    del_flags = 0
    if char != "-":
        while True:
            flag = FLAGS[char]
            if source.istext:
                if char == 'L':
                    msg = "bad inline flags: cannot use 'L' flag with a str pattern"
                    raise source.error(msg)
            else:
                if char == 'u':
                    msg = "bad inline flags: cannot use 'u' flag with a bytes pattern"
                    raise source.error(msg)
            add_flags |= flag
            if (flag & TYPE_FLAGS) and (add_flags & TYPE_FLAGS) != flag:
                msg = "bad inline flags: flags 'a', 'u' and 'L' are incompatible"
                raise source.error(msg)
            char = sourceget()
            if char is None:
                raise source.error("missing -, : or )")
            if char in ")-:":
                break
            if char not in FLAGS:
                msg = "unknown flag" if char.isalpha() else "missing -, : or )"
                raise source.error(msg, len(char))
    if char == ")":
        state.flags |= add_flags
        return None
    if add_flags & GLOBAL_FLAGS:
        raise source.error("bad inline flags: cannot turn on global flag", 1)
    if char == "-":
        char = sourceget()
        if char is None:
            raise source.error("missing flag")
        if char not in FLAGS:
            msg = "unknown flag" if char.isalpha() else "missing flag"
            raise source.error(msg, len(char))
        while True:
            flag = FLAGS[char]
            if flag & TYPE_FLAGS:
                msg = "bad inline flags: cannot turn off flags 'a', 'u' and 'L'"
                raise source.error(msg)
            del_flags |= flag
            char = sourceget()
            if char is None:
                raise source.error("missing :")
            if char == ":":
                break
            if char not in FLAGS:
                msg = "unknown flag" if char.isalpha() else "missing :"
                raise source.error(msg, len(char))
    assert char == ":"
    if del_flags & GLOBAL_FLAGS:
        raise source.error("bad inline flags: cannot turn off global flag", 1)
    if add_flags & del_flags:
        raise source.error("bad inline flags: flag turned on and off", 1)
    return add_flags, del_flags

def fix_flags(src, flags):
    # Check and fix flags according to the type of pattern (str or bytes)
    if isinstance(src, str):
        if flags & SRE_FLAG_LOCALE:
            raise ValueError("cannot use LOCALE flag with a str pattern")
        if not flags & SRE_FLAG_ASCII:
            flags |= SRE_FLAG_UNICODE
        elif flags & SRE_FLAG_UNICODE:
            raise ValueError("ASCII and UNICODE flags are incompatible")
    else:
        if flags & SRE_FLAG_UNICODE:
            raise ValueError("cannot use UNICODE flag with a bytes pattern")
        if flags & SRE_FLAG_LOCALE and flags & SRE_FLAG_ASCII:
            raise ValueError("ASCII and LOCALE flags are incompatible")
    return flags

def parse(str, flags=0, state=None):
    # parse 're' pattern into list of (opcode, argument) tuples

    source = Tokenizer(str)

    if state is None:
        state = State()
    state.flags = flags
    state.str = str

    p = _parse_sub(source, state, flags & SRE_FLAG_VERBOSE, 0)
    p.state.flags = fix_flags(str, p.state.flags)

    if source.next is not None:
        assert source.next == ")"
        raise source.error("unbalanced parenthesis")

    for g in p.state.grouprefpos:
        if g >= p.state.groups:
            msg = "invalid group reference %d" % g
            raise error(msg, str, p.state.grouprefpos[g])

    if flags & SRE_FLAG_DEBUG:
        p.dump()

    return p

def parse_template(source, state):
    # parse 're' replacement string into list of literals and
    # group references
    s = Tokenizer(source)
    sget = s.get
    groups = []
    literals = []
    literal = []
    lappend = literal.append
    def addgroup(index, pos):
        if index > state.groups:
            raise s.error("invalid group reference %d" % index, pos)
        if literal:
            literals.append(''.join(literal))
            del literal[:]
        groups.append((len(literals), index))
        literals.append(None)
    groupindex = state.groupindex
    while True:
        this = sget()
        if this is None:
            break # end of replacement string
        if this[0] == "\\":
            # group
            c = this[1]
            if c == "g":
                if not s.match("<"):
                    raise s.error("missing <")
                name = s.getuntil(">", "group name")
                if name.isidentifier():
                    s.checkgroupname(name, 1, -1)
                    try:
                        index = groupindex[name]
                    except KeyError:
                        raise IndexError("unknown group name %r" % name) from None
                else:
                    try:
                        index = int(name)
                        if index < 0:
                            raise ValueError
                    except ValueError:
                        raise s.error("bad character in group name %r" % name,
                                      len(name) + 1) from None
                    if index >= MAXGROUPS:
                        raise s.error("invalid group reference %d" % index,
                                      len(name) + 1)
                    if not (name.isdecimal() and name.isascii()):
                        import warnings
                        warnings.warn(
                            "bad character in group name %s at position %d" %
                            (repr(name) if s.istext else ascii(name),
                             s.tell() - len(name) - 1),
                            DeprecationWarning, stacklevel=5
                        )
                addgroup(index, len(name) + 1)
            elif c == "0":
                if s.next in OCTDIGITS:
                    this += sget()
                    if s.next in OCTDIGITS:
                        this += sget()
                lappend(chr(int(this[1:], 8) & 0xff))
            elif c in DIGITS:
                isoctal = False
                if s.next in DIGITS:
                    this += sget()
                    if (c in OCTDIGITS and this[2] in OCTDIGITS and
                        s.next in OCTDIGITS):
                        this += sget()
                        isoctal = True
                        c = int(this[1:], 8)
                        if c > 0o377:
                            raise s.error('octal escape value %s outside of '
                                          'range 0-0o377' % this, len(this))
                        lappend(chr(c))
                if not isoctal:
                    addgroup(int(this[1:]), len(this) - 1)
            else:
                try:
                    this = chr(ESCAPES[this][1])
                except KeyError:
                    if c in ASCIILETTERS:
                        raise s.error('bad escape %s' % this, len(this)) from None
                lappend(this)
        else:
            lappend(this)
    if literal:
        literals.append(''.join(literal))
    if not isinstance(source, str):
        # The tokenizer implicitly decodes bytes objects as latin-1, we must
        # therefore re-encode the final representation.
        literals = [None if s is None else s.encode('latin-1') for s in literals]
    return groups, literals

def expand_template(template, match):
    g = match.group
    empty = match.string[:0]
    groups, literals = template
    literals = literals[:]
    try:
        for index, group in groups:
            literals[index] = g(group) or empty
    except IndexError:
        raise error("invalid group reference %d" % index) from None
    return empty.join(literals)
PKV*]w7�e�e_compiler.pynu�[���#
# Secret Labs' Regular Expression Engine
#
# convert template to internal format
#
# Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
#
# See the __init__.py file for information on usage and redistribution.
#

"""Internal support module for sre"""

import _sre
from . import _parser
from ._constants import *
from ._casefix import _EXTRA_CASES

assert _sre.MAGIC == MAGIC, "SRE module mismatch"

_LITERAL_CODES = {LITERAL, NOT_LITERAL}
_SUCCESS_CODES = {SUCCESS, FAILURE}
_ASSERT_CODES = {ASSERT, ASSERT_NOT}
_UNIT_CODES = _LITERAL_CODES | {ANY, IN}

_REPEATING_CODES = {
    MIN_REPEAT: (REPEAT, MIN_UNTIL, MIN_REPEAT_ONE),
    MAX_REPEAT: (REPEAT, MAX_UNTIL, REPEAT_ONE),
    POSSESSIVE_REPEAT: (POSSESSIVE_REPEAT, SUCCESS, POSSESSIVE_REPEAT_ONE),
}

def _combine_flags(flags, add_flags, del_flags,
                   TYPE_FLAGS=_parser.TYPE_FLAGS):
    if add_flags & TYPE_FLAGS:
        flags &= ~TYPE_FLAGS
    return (flags | add_flags) & ~del_flags

def _compile(code, pattern, flags):
    # internal: compile a (sub)pattern
    emit = code.append
    _len = len
    LITERAL_CODES = _LITERAL_CODES
    REPEATING_CODES = _REPEATING_CODES
    SUCCESS_CODES = _SUCCESS_CODES
    ASSERT_CODES = _ASSERT_CODES
    iscased = None
    tolower = None
    fixes = None
    if flags & SRE_FLAG_IGNORECASE and not flags & SRE_FLAG_LOCALE:
        if flags & SRE_FLAG_UNICODE:
            iscased = _sre.unicode_iscased
            tolower = _sre.unicode_tolower
            fixes = _EXTRA_CASES
        else:
            iscased = _sre.ascii_iscased
            tolower = _sre.ascii_tolower
    for op, av in pattern:
        if op in LITERAL_CODES:
            if not flags & SRE_FLAG_IGNORECASE:
                emit(op)
                emit(av)
            elif flags & SRE_FLAG_LOCALE:
                emit(OP_LOCALE_IGNORE[op])
                emit(av)
            elif not iscased(av):
                emit(op)
                emit(av)
            else:
                lo = tolower(av)
                if not fixes:  # ascii
                    emit(OP_IGNORE[op])
                    emit(lo)
                elif lo not in fixes:
                    emit(OP_UNICODE_IGNORE[op])
                    emit(lo)
                else:
                    emit(IN_UNI_IGNORE)
                    skip = _len(code); emit(0)
                    if op is NOT_LITERAL:
                        emit(NEGATE)
                    for k in (lo,) + fixes[lo]:
                        emit(LITERAL)
                        emit(k)
                    emit(FAILURE)
                    code[skip] = _len(code) - skip
        elif op is IN:
            charset, hascased = _optimize_charset(av, iscased, tolower, fixes)
            if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE:
                emit(IN_LOC_IGNORE)
            elif not hascased:
                emit(IN)
            elif not fixes:  # ascii
                emit(IN_IGNORE)
            else:
                emit(IN_UNI_IGNORE)
            skip = _len(code); emit(0)
            _compile_charset(charset, flags, code)
            code[skip] = _len(code) - skip
        elif op is ANY:
            if flags & SRE_FLAG_DOTALL:
                emit(ANY_ALL)
            else:
                emit(ANY)
        elif op in REPEATING_CODES:
            if flags & SRE_FLAG_TEMPLATE:
                raise error("internal: unsupported template operator %r" % (op,))
            if _simple(av[2]):
                emit(REPEATING_CODES[op][2])
                skip = _len(code); emit(0)
                emit(av[0])
                emit(av[1])
                _compile(code, av[2], flags)
                emit(SUCCESS)
                code[skip] = _len(code) - skip
            else:
                emit(REPEATING_CODES[op][0])
                skip = _len(code); emit(0)
                emit(av[0])
                emit(av[1])
                _compile(code, av[2], flags)
                code[skip] = _len(code) - skip
                emit(REPEATING_CODES[op][1])
        elif op is SUBPATTERN:
            group, add_flags, del_flags, p = av
            if group:
                emit(MARK)
                emit((group-1)*2)
            # _compile_info(code, p, _combine_flags(flags, add_flags, del_flags))
            _compile(code, p, _combine_flags(flags, add_flags, del_flags))
            if group:
                emit(MARK)
                emit((group-1)*2+1)
        elif op is ATOMIC_GROUP:
            # Atomic Groups are handled by starting with an Atomic
            # Group op code, then putting in the atomic group pattern
            # and finally a success op code to tell any repeat
            # operations within the Atomic Group to stop eating and
            # pop their stack if they reach it
            emit(ATOMIC_GROUP)
            skip = _len(code); emit(0)
            _compile(code, av, flags)
            emit(SUCCESS)
            code[skip] = _len(code) - skip
        elif op in SUCCESS_CODES:
            emit(op)
        elif op in ASSERT_CODES:
            emit(op)
            skip = _len(code); emit(0)
            if av[0] >= 0:
                emit(0) # look ahead
            else:
                lo, hi = av[1].getwidth()
                if lo > MAXCODE:
                    raise error("looks too much behind")
                if lo != hi:
                    raise error("look-behind requires fixed-width pattern")
                emit(lo) # look behind
            _compile(code, av[1], flags)
            emit(SUCCESS)
            code[skip] = _len(code) - skip
        elif op is AT:
            emit(op)
            if flags & SRE_FLAG_MULTILINE:
                av = AT_MULTILINE.get(av, av)
            if flags & SRE_FLAG_LOCALE:
                av = AT_LOCALE.get(av, av)
            elif flags & SRE_FLAG_UNICODE:
                av = AT_UNICODE.get(av, av)
            emit(av)
        elif op is BRANCH:
            emit(op)
            tail = []
            tailappend = tail.append
            for av in av[1]:
                skip = _len(code); emit(0)
                # _compile_info(code, av, flags)
                _compile(code, av, flags)
                emit(JUMP)
                tailappend(_len(code)); emit(0)
                code[skip] = _len(code) - skip
            emit(FAILURE) # end of branch
            for tail in tail:
                code[tail] = _len(code) - tail
        elif op is CATEGORY:
            emit(op)
            if flags & SRE_FLAG_LOCALE:
                av = CH_LOCALE[av]
            elif flags & SRE_FLAG_UNICODE:
                av = CH_UNICODE[av]
            emit(av)
        elif op is GROUPREF:
            if not flags & SRE_FLAG_IGNORECASE:
                emit(op)
            elif flags & SRE_FLAG_LOCALE:
                emit(GROUPREF_LOC_IGNORE)
            elif not fixes:  # ascii
                emit(GROUPREF_IGNORE)
            else:
                emit(GROUPREF_UNI_IGNORE)
            emit(av-1)
        elif op is GROUPREF_EXISTS:
            emit(op)
            emit(av[0]-1)
            skipyes = _len(code); emit(0)
            _compile(code, av[1], flags)
            if av[2]:
                emit(JUMP)
                skipno = _len(code); emit(0)
                code[skipyes] = _len(code) - skipyes + 1
                _compile(code, av[2], flags)
                code[skipno] = _len(code) - skipno
            else:
                code[skipyes] = _len(code) - skipyes + 1
        else:
            raise error("internal: unsupported operand type %r" % (op,))

def _compile_charset(charset, flags, code):
    # compile charset subprogram
    emit = code.append
    for op, av in charset:
        emit(op)
        if op is NEGATE:
            pass
        elif op is LITERAL:
            emit(av)
        elif op is RANGE or op is RANGE_UNI_IGNORE:
            emit(av[0])
            emit(av[1])
        elif op is CHARSET:
            code.extend(av)
        elif op is BIGCHARSET:
            code.extend(av)
        elif op is CATEGORY:
            if flags & SRE_FLAG_LOCALE:
                emit(CH_LOCALE[av])
            elif flags & SRE_FLAG_UNICODE:
                emit(CH_UNICODE[av])
            else:
                emit(av)
        else:
            raise error("internal: unsupported set operator %r" % (op,))
    emit(FAILURE)

def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
    # internal: optimize character set
    out = []
    tail = []
    charmap = bytearray(256)
    hascased = False
    for op, av in charset:
        while True:
            try:
                if op is LITERAL:
                    if fixup:
                        lo = fixup(av)
                        charmap[lo] = 1
                        if fixes and lo in fixes:
                            for k in fixes[lo]:
                                charmap[k] = 1
                        if not hascased and iscased(av):
                            hascased = True
                    else:
                        charmap[av] = 1
                elif op is RANGE:
                    r = range(av[0], av[1]+1)
                    if fixup:
                        if fixes:
                            for i in map(fixup, r):
                                charmap[i] = 1
                                if i in fixes:
                                    for k in fixes[i]:
                                        charmap[k] = 1
                        else:
                            for i in map(fixup, r):
                                charmap[i] = 1
                        if not hascased:
                            hascased = any(map(iscased, r))
                    else:
                        for i in r:
                            charmap[i] = 1
                elif op is NEGATE:
                    out.append((op, av))
                else:
                    tail.append((op, av))
            except IndexError:
                if len(charmap) == 256:
                    # character set contains non-UCS1 character codes
                    charmap += b'\0' * 0xff00
                    continue
                # Character set contains non-BMP character codes.
                # For range, all BMP characters in the range are already
                # proceeded.
                if fixup:
                    hascased = True
                    # For now, IN_UNI_IGNORE+LITERAL and
                    # IN_UNI_IGNORE+RANGE_UNI_IGNORE work for all non-BMP
                    # characters, because two characters (at least one of
                    # which is not in the BMP) match case-insensitively
                    # if and only if:
                    # 1) c1.lower() == c2.lower()
                    # 2) c1.lower() == c2 or c1.lower().upper() == c2
                    # Also, both c.lower() and c.lower().upper() are single
                    # characters for every non-BMP character.
                    if op is RANGE:
                        op = RANGE_UNI_IGNORE
                tail.append((op, av))
            break

    # compress character map
    runs = []
    q = 0
    while True:
        p = charmap.find(1, q)
        if p < 0:
            break
        if len(runs) >= 2:
            runs = None
            break
        q = charmap.find(0, p)
        if q < 0:
            runs.append((p, len(charmap)))
            break
        runs.append((p, q))
    if runs is not None:
        # use literal/range
        for p, q in runs:
            if q - p == 1:
                out.append((LITERAL, p))
            else:
                out.append((RANGE, (p, q - 1)))
        out += tail
        # if the case was changed or new representation is more compact
        if hascased or len(out) < len(charset):
            return out, hascased
        # else original character set is good enough
        return charset, hascased

    # use bitmap
    if len(charmap) == 256:
        data = _mk_bitmap(charmap)
        out.append((CHARSET, data))
        out += tail
        return out, hascased

    # To represent a big charset, first a bitmap of all characters in the
    # set is constructed. Then, this bitmap is sliced into chunks of 256
    # characters, duplicate chunks are eliminated, and each chunk is
    # given a number. In the compiled expression, the charset is
    # represented by a 32-bit word sequence, consisting of one word for
    # the number of different chunks, a sequence of 256 bytes (64 words)
    # of chunk numbers indexed by their original chunk position, and a
    # sequence of 256-bit chunks (8 words each).

    # Compression is normally good: in a typical charset, large ranges of
    # Unicode will be either completely excluded (e.g. if only cyrillic
    # letters are to be matched), or completely included (e.g. if large
    # subranges of Kanji match). These ranges will be represented by
    # chunks of all one-bits or all zero-bits.

    # Matching can be also done efficiently: the more significant byte of
    # the Unicode character is an index into the chunk number, and the
    # less significant byte is a bit index in the chunk (just like the
    # CHARSET matching).

    charmap = bytes(charmap) # should be hashable
    comps = {}
    mapping = bytearray(256)
    block = 0
    data = bytearray()
    for i in range(0, 65536, 256):
        chunk = charmap[i: i + 256]
        if chunk in comps:
            mapping[i // 256] = comps[chunk]
        else:
            mapping[i // 256] = comps[chunk] = block
            block += 1
            data += chunk
    data = _mk_bitmap(data)
    data[0:0] = [block] + _bytes_to_codes(mapping)
    out.append((BIGCHARSET, data))
    out += tail
    return out, hascased

_CODEBITS = _sre.CODESIZE * 8
MAXCODE = (1 << _CODEBITS) - 1
_BITS_TRANS = b'0' + b'1' * 255
def _mk_bitmap(bits, _CODEBITS=_CODEBITS, _int=int):
    s = bits.translate(_BITS_TRANS)[::-1]
    return [_int(s[i - _CODEBITS: i], 2)
            for i in range(len(s), 0, -_CODEBITS)]

def _bytes_to_codes(b):
    # Convert block indices to word array
    a = memoryview(b).cast('I')
    assert a.itemsize == _sre.CODESIZE
    assert len(a) * a.itemsize == len(b)
    return a.tolist()

def _simple(p):
    # check if this subpattern is a "simple" operator
    if len(p) != 1:
        return False
    op, av = p[0]
    if op is SUBPATTERN:
        return av[0] is None and _simple(av[-1])
    return op in _UNIT_CODES

def _generate_overlap_table(prefix):
    """
    Generate an overlap table for the following prefix.
    An overlap table is a table of the same size as the prefix which
    informs about the potential self-overlap for each index in the prefix:
    - if overlap[i] == 0, prefix[i:] can't overlap prefix[0:...]
    - if overlap[i] == k with 0 < k <= i, prefix[i-k+1:i+1] overlaps with
      prefix[0:k]
    """
    table = [0] * len(prefix)
    for i in range(1, len(prefix)):
        idx = table[i - 1]
        while prefix[i] != prefix[idx]:
            if idx == 0:
                table[i] = 0
                break
            idx = table[idx - 1]
        else:
            table[i] = idx + 1
    return table

def _get_iscased(flags):
    if not flags & SRE_FLAG_IGNORECASE:
        return None
    elif flags & SRE_FLAG_UNICODE:
        return _sre.unicode_iscased
    else:
        return _sre.ascii_iscased

def _get_literal_prefix(pattern, flags):
    # look for literal prefix
    prefix = []
    prefixappend = prefix.append
    prefix_skip = None
    iscased = _get_iscased(flags)
    for op, av in pattern.data:
        if op is LITERAL:
            if iscased and iscased(av):
                break
            prefixappend(av)
        elif op is SUBPATTERN:
            group, add_flags, del_flags, p = av
            flags1 = _combine_flags(flags, add_flags, del_flags)
            if flags1 & SRE_FLAG_IGNORECASE and flags1 & SRE_FLAG_LOCALE:
                break
            prefix1, prefix_skip1, got_all = _get_literal_prefix(p, flags1)
            if prefix_skip is None:
                if group is not None:
                    prefix_skip = len(prefix)
                elif prefix_skip1 is not None:
                    prefix_skip = len(prefix) + prefix_skip1
            prefix.extend(prefix1)
            if not got_all:
                break
        else:
            break
    else:
        return prefix, prefix_skip, True
    return prefix, prefix_skip, False

def _get_charset_prefix(pattern, flags):
    while True:
        if not pattern.data:
            return None
        op, av = pattern.data[0]
        if op is not SUBPATTERN:
            break
        group, add_flags, del_flags, pattern = av
        flags = _combine_flags(flags, add_flags, del_flags)
        if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE:
            return None

    iscased = _get_iscased(flags)
    if op is LITERAL:
        if iscased and iscased(av):
            return None
        return [(op, av)]
    elif op is BRANCH:
        charset = []
        charsetappend = charset.append
        for p in av[1]:
            if not p:
                return None
            op, av = p[0]
            if op is LITERAL and not (iscased and iscased(av)):
                charsetappend((op, av))
            else:
                return None
        return charset
    elif op is IN:
        charset = av
        if iscased:
            for op, av in charset:
                if op is LITERAL:
                    if iscased(av):
                        return None
                elif op is RANGE:
                    if av[1] > 0xffff:
                        return None
                    if any(map(iscased, range(av[0], av[1]+1))):
                        return None
        return charset
    return None

def _compile_info(code, pattern, flags):
    # internal: compile an info block.  in the current version,
    # this contains min/max pattern width, and an optional literal
    # prefix or a character map
    lo, hi = pattern.getwidth()
    if hi > MAXCODE:
        hi = MAXCODE
    if lo == 0:
        code.extend([INFO, 4, 0, lo, hi])
        return
    # look for a literal prefix
    prefix = []
    prefix_skip = 0
    charset = [] # not used
    if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE):
        # look for literal prefix
        prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags)
        # if no prefix, look for charset prefix
        if not prefix:
            charset = _get_charset_prefix(pattern, flags)
##     if prefix:
##         print("*** PREFIX", prefix, prefix_skip)
##     if charset:
##         print("*** CHARSET", charset)
    # add an info block
    emit = code.append
    emit(INFO)
    skip = len(code); emit(0)
    # literal flag
    mask = 0
    if prefix:
        mask = SRE_INFO_PREFIX
        if prefix_skip is None and got_all:
            mask = mask | SRE_INFO_LITERAL
    elif charset:
        mask = mask | SRE_INFO_CHARSET
    emit(mask)
    # pattern length
    if lo < MAXCODE:
        emit(lo)
    else:
        emit(MAXCODE)
        prefix = prefix[:MAXCODE]
    emit(hi)
    # add literal prefix
    if prefix:
        emit(len(prefix)) # length
        if prefix_skip is None:
            prefix_skip =  len(prefix)
        emit(prefix_skip) # skip
        code.extend(prefix)
        # generate overlap table
        code.extend(_generate_overlap_table(prefix))
    elif charset:
        charset, hascased = _optimize_charset(charset)
        assert not hascased
        _compile_charset(charset, flags, code)
    code[skip] = len(code) - skip

def isstring(obj):
    return isinstance(obj, (str, bytes))

def _code(p, flags):

    flags = p.state.flags | flags
    code = []

    # compile info block
    _compile_info(code, p, flags)

    # compile the pattern
    _compile(code, p.data, flags)

    code.append(SUCCESS)

    return code

def _hex_code(code):
    return '[%s]' % ', '.join('%#0*x' % (_sre.CODESIZE*2+2, x) for x in code)

def dis(code):
    import sys

    labels = set()
    level = 0
    offset_width = len(str(len(code) - 1))

    def dis_(start, end):
        def print_(*args, to=None):
            if to is not None:
                labels.add(to)
                args += ('(to %d)' % (to,),)
            print('%*d%s ' % (offset_width, start, ':' if start in labels else '.'),
                  end='  '*(level-1))
            print(*args)

        def print_2(*args):
            print(end=' '*(offset_width + 2*level))
            print(*args)

        nonlocal level
        level += 1
        i = start
        while i < end:
            start = i
            op = code[i]
            i += 1
            op = OPCODES[op]
            if op in (SUCCESS, FAILURE, ANY, ANY_ALL,
                      MAX_UNTIL, MIN_UNTIL, NEGATE):
                print_(op)
            elif op in (LITERAL, NOT_LITERAL,
                        LITERAL_IGNORE, NOT_LITERAL_IGNORE,
                        LITERAL_UNI_IGNORE, NOT_LITERAL_UNI_IGNORE,
                        LITERAL_LOC_IGNORE, NOT_LITERAL_LOC_IGNORE):
                arg = code[i]
                i += 1
                print_(op, '%#02x (%r)' % (arg, chr(arg)))
            elif op is AT:
                arg = code[i]
                i += 1
                arg = str(ATCODES[arg])
                assert arg[:3] == 'AT_'
                print_(op, arg[3:])
            elif op is CATEGORY:
                arg = code[i]
                i += 1
                arg = str(CHCODES[arg])
                assert arg[:9] == 'CATEGORY_'
                print_(op, arg[9:])
            elif op in (IN, IN_IGNORE, IN_UNI_IGNORE, IN_LOC_IGNORE):
                skip = code[i]
                print_(op, skip, to=i+skip)
                dis_(i+1, i+skip)
                i += skip
            elif op in (RANGE, RANGE_UNI_IGNORE):
                lo, hi = code[i: i+2]
                i += 2
                print_(op, '%#02x %#02x (%r-%r)' % (lo, hi, chr(lo), chr(hi)))
            elif op is CHARSET:
                print_(op, _hex_code(code[i: i + 256//_CODEBITS]))
                i += 256//_CODEBITS
            elif op is BIGCHARSET:
                arg = code[i]
                i += 1
                mapping = list(b''.join(x.to_bytes(_sre.CODESIZE, sys.byteorder)
                                        for x in code[i: i + 256//_sre.CODESIZE]))
                print_(op, arg, mapping)
                i += 256//_sre.CODESIZE
                level += 1
                for j in range(arg):
                    print_2(_hex_code(code[i: i + 256//_CODEBITS]))
                    i += 256//_CODEBITS
                level -= 1
            elif op in (MARK, GROUPREF, GROUPREF_IGNORE, GROUPREF_UNI_IGNORE,
                        GROUPREF_LOC_IGNORE):
                arg = code[i]
                i += 1
                print_(op, arg)
            elif op is JUMP:
                skip = code[i]
                print_(op, skip, to=i+skip)
                i += 1
            elif op is BRANCH:
                skip = code[i]
                print_(op, skip, to=i+skip)
                while skip:
                    dis_(i+1, i+skip)
                    i += skip
                    start = i
                    skip = code[i]
                    if skip:
                        print_('branch', skip, to=i+skip)
                    else:
                        print_(FAILURE)
                i += 1
            elif op in (REPEAT, REPEAT_ONE, MIN_REPEAT_ONE,
                        POSSESSIVE_REPEAT, POSSESSIVE_REPEAT_ONE):
                skip, min, max = code[i: i+3]
                if max == MAXREPEAT:
                    max = 'MAXREPEAT'
                print_(op, skip, min, max, to=i+skip)
                dis_(i+3, i+skip)
                i += skip
            elif op is GROUPREF_EXISTS:
                arg, skip = code[i: i+2]
                print_(op, arg, skip, to=i+skip)
                i += 2
            elif op in (ASSERT, ASSERT_NOT):
                skip, arg = code[i: i+2]
                print_(op, skip, arg, to=i+skip)
                dis_(i+2, i+skip)
                i += skip
            elif op is ATOMIC_GROUP:
                skip = code[i]
                print_(op, skip, to=i+skip)
                dis_(i+1, i+skip)
                i += skip
            elif op is INFO:
                skip, flags, min, max = code[i: i+4]
                if max == MAXREPEAT:
                    max = 'MAXREPEAT'
                print_(op, skip, bin(flags), min, max, to=i+skip)
                start = i+4
                if flags & SRE_INFO_PREFIX:
                    prefix_len, prefix_skip = code[i+4: i+6]
                    print_2('  prefix_skip', prefix_skip)
                    start = i + 6
                    prefix = code[start: start+prefix_len]
                    print_2('  prefix',
                            '[%s]' % ', '.join('%#02x' % x for x in prefix),
                            '(%r)' % ''.join(map(chr, prefix)))
                    start += prefix_len
                    print_2('  overlap', code[start: start+prefix_len])
                    start += prefix_len
                if flags & SRE_INFO_CHARSET:
                    level += 1
                    print_2('in')
                    dis_(start, i+skip)
                    level -= 1
                i += skip
            else:
                raise ValueError(op)

        level -= 1

    dis_(0, len(code))


def compile(p, flags=0):
    # internal: convert pattern list to internal format

    if isstring(p):
        pattern = p
        p = _parser.parse(p, flags)
    else:
        pattern = None

    code = _code(p, flags)

    if flags & SRE_FLAG_DEBUG:
        print()
        dis(code)

    # map in either direction
    groupindex = p.state.groupdict
    indexgroup = [None] * p.state.groups
    for k, i in groupindex.items():
        indexgroup[i] = k

    return _sre.compile(
        pattern, flags | p.state.flags, code,
        p.state.groups-1,
        groupindex, tuple(indexgroup)
        )
PKV*]L�\>>__init__.pynu�[���#
# Secret Labs' Regular Expression Engine
#
# re-compatible interface for the sre matching engine
#
# Copyright (c) 1998-2001 by Secret Labs AB.  All rights reserved.
#
# This version of the SRE library can be redistributed under CNRI's
# Python 1.6 license.  For any other use, please contact Secret Labs
# AB (info@pythonware.com).
#
# Portions of this engine have been developed in cooperation with
# CNRI.  Hewlett-Packard provided funding for 1.6 integration and
# other compatibility work.
#

r"""Support for regular expressions (RE).

This module provides regular expression matching operations similar to
those found in Perl.  It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range.

Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves.  You can
concatenate ordinary characters, so last matches the string 'last'.

The special characters are:
    "."      Matches any character except a newline.
    "^"      Matches the start of the string.
    "$"      Matches the end of the string or just before the newline at
             the end of the string.
    "*"      Matches 0 or more (greedy) repetitions of the preceding RE.
             Greedy means that it will match as many repetitions as possible.
    "+"      Matches 1 or more (greedy) repetitions of the preceding RE.
    "?"      Matches 0 or 1 (greedy) of the preceding RE.
    *?,+?,?? Non-greedy versions of the previous three special characters.
    {m,n}    Matches from m to n repetitions of the preceding RE.
    {m,n}?   Non-greedy version of the above.
    "\\"     Either escapes special characters or signals a special sequence.
    []       Indicates a set of characters.
             A "^" as the first character indicates a complementing set.
    "|"      A|B, creates an RE that will match either A or B.
    (...)    Matches the RE inside the parentheses.
             The contents can be retrieved or matched later in the string.
    (?aiLmsux) The letters set the corresponding flags defined below.
    (?:...)  Non-grouping version of regular parentheses.
    (?P<name>...) The substring matched by the group is accessible by name.
    (?P=name)     Matches the text matched earlier by the group named name.
    (?#...)  A comment; ignored.
    (?=...)  Matches if ... matches next, but doesn't consume the string.
    (?!...)  Matches if ... doesn't match next.
    (?<=...) Matches if preceded by ... (must be fixed length).
    (?<!...) Matches if not preceded by ... (must be fixed length).
    (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
                       the (optional) no pattern otherwise.

The special sequences consist of "\\" and a character from the list
below.  If the ordinary character is not on the list, then the
resulting RE will match the second character.
    \number  Matches the contents of the group of the same number.
    \A       Matches only at the start of the string.
    \Z       Matches only at the end of the string.
    \b       Matches the empty string, but only at the start or end of a word.
    \B       Matches the empty string, but not at the start or end of a word.
    \d       Matches any decimal digit; equivalent to the set [0-9] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode digits.
    \D       Matches any non-digit character; equivalent to [^\d].
    \s       Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode whitespace characters.
    \S       Matches any non-whitespace character; equivalent to [^\s].
    \w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
             in bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the
             range of Unicode alphanumeric characters (letters plus digits
             plus underscore).
             With LOCALE, it will match the set [0-9_] plus characters defined
             as letters for the current locale.
    \W       Matches the complement of \w.
    \\       Matches a literal backslash.

This module exports the following functions:
    match     Match a regular expression pattern to the beginning of a string.
    fullmatch Match a regular expression pattern to all of a string.
    search    Search a string for the presence of a pattern.
    sub       Substitute occurrences of a pattern found in a string.
    subn      Same as sub, but also return the number of substitutions made.
    split     Split a string by the occurrences of a pattern.
    findall   Find all occurrences of a pattern in a string.
    finditer  Return an iterator yielding a Match object for each match.
    compile   Compile a pattern into a Pattern object.
    purge     Clear the regular expression cache.
    escape    Backslash all non-alphanumerics in a string.

Each function other than purge and escape can take an optional 'flags' argument
consisting of one or more of the following module constants, joined by "|".
A, L, and U are mutually exclusive.
    A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D
                   match the corresponding ASCII character categories
                   (rather than the whole Unicode categories, which is the
                   default).
                   For bytes patterns, this flag is the only available
                   behaviour and needn't be specified.
    I  IGNORECASE  Perform case-insensitive matching.
    L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
    M  MULTILINE   "^" matches the beginning of lines (after a newline)
                   as well as the string.
                   "$" matches the end of lines (before a newline) as well
                   as the end of the string.
    S  DOTALL      "." matches any character at all, including the newline.
    X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
    U  UNICODE     For compatibility only. Ignored for string patterns (it
                   is the default), and forbidden for bytes patterns.

This module also defines an exception 'error'.

"""

import enum
from . import _compiler, _parser
import functools


# public symbols
__all__ = [
    "match", "fullmatch", "search", "sub", "subn", "split",
    "findall", "finditer", "compile", "purge", "template", "escape",
    "error", "Pattern", "Match", "A", "I", "L", "M", "S", "X", "U",
    "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
    "UNICODE", "NOFLAG", "RegexFlag",
]

__version__ = "2.2.1"

@enum.global_enum
@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
class RegexFlag:
    NOFLAG = 0
    ASCII = A = _compiler.SRE_FLAG_ASCII # assume ascii "locale"
    IGNORECASE = I = _compiler.SRE_FLAG_IGNORECASE # ignore case
    LOCALE = L = _compiler.SRE_FLAG_LOCALE # assume current 8-bit locale
    UNICODE = U = _compiler.SRE_FLAG_UNICODE # assume unicode "locale"
    MULTILINE = M = _compiler.SRE_FLAG_MULTILINE # make anchors look for newline
    DOTALL = S = _compiler.SRE_FLAG_DOTALL # make dot match newline
    VERBOSE = X = _compiler.SRE_FLAG_VERBOSE # ignore whitespace and comments
    # sre extensions (experimental, don't rely on these)
    TEMPLATE = T = _compiler.SRE_FLAG_TEMPLATE # unknown purpose, deprecated
    DEBUG = _compiler.SRE_FLAG_DEBUG # dump pattern after compilation
    __str__ = object.__str__
    _numeric_repr_ = hex

# sre exception
error = _compiler.error

# --------------------------------------------------------------------
# public interface

def match(pattern, string, flags=0):
    """Try to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found."""
    return _compile(pattern, flags).match(string)

def fullmatch(pattern, string, flags=0):
    """Try to apply the pattern to all of the string, returning
    a Match object, or None if no match was found."""
    return _compile(pattern, flags).fullmatch(string)

def search(pattern, string, flags=0):
    """Scan through string looking for a match to the pattern, returning
    a Match object, or None if no match was found."""
    return _compile(pattern, flags).search(string)

def sub(pattern, repl, string, count=0, flags=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(pattern, flags).sub(repl, string, count)

def subn(pattern, repl, string, count=0, flags=0):
    """Return a 2-tuple containing (new_string, number).
    new_string is the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in the source
    string by the replacement repl.  number is the number of
    substitutions that were made. 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(pattern, flags).subn(repl, string, count)

def split(pattern, string, maxsplit=0, flags=0):
    """Split the source string by the occurrences of the pattern,
    returning a list containing the resulting substrings.  If
    capturing parentheses are used in pattern, then the text of all
    groups in the pattern are also returned as part of the resulting
    list.  If maxsplit is nonzero, at most maxsplit splits occur,
    and the remainder of the string is returned as the final element
    of the list."""
    return _compile(pattern, flags).split(string, maxsplit)

def findall(pattern, string, flags=0):
    """Return a list of all non-overlapping matches in the string.

    If one or more capturing 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(pattern, flags).findall(string)

def finditer(pattern, string, flags=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(pattern, flags).finditer(string)

def compile(pattern, flags=0):
    "Compile a regular expression pattern, returning a Pattern object."
    return _compile(pattern, flags)

def purge():
    "Clear the regular expression caches"
    _cache.clear()
    _compile_repl.cache_clear()

def template(pattern, flags=0):
    "Compile a template pattern, returning a Pattern object, deprecated"
    import warnings
    warnings.warn("The re.template() function is deprecated "
                  "as it is an undocumented function "
                  "without an obvious purpose. "
                  "Use re.compile() instead.",
                  DeprecationWarning)
    with warnings.catch_warnings():
        warnings.simplefilter("ignore", DeprecationWarning)  # warn just once
        return _compile(pattern, flags|T)

# SPECIAL_CHARS
# closing ')', '}' and ']'
# '-' (a range in character set)
# '&', '~', (extended character set operations)
# '#' (comment) and WHITESPACE (ignored) in verbose mode
_special_chars_map = {i: '\\' + chr(i) for i in b'()[]{}?*+-|^$\\.&~# \t\n\r\v\f'}

def escape(pattern):
    """
    Escape special characters in a string.
    """
    if isinstance(pattern, str):
        return pattern.translate(_special_chars_map)
    else:
        pattern = str(pattern, 'latin1')
        return pattern.translate(_special_chars_map).encode('latin1')

Pattern = type(_compiler.compile('', 0))
Match = type(_compiler.compile('', 0).match(''))

# --------------------------------------------------------------------
# internals

_cache = {}  # ordered!

_MAXCACHE = 512
def _compile(pattern, flags):
    # internal: compile pattern
    if isinstance(flags, RegexFlag):
        flags = flags.value
    try:
        return _cache[type(pattern), pattern, flags]
    except KeyError:
        pass
    if isinstance(pattern, Pattern):
        if flags:
            raise ValueError(
                "cannot process flags argument with a compiled pattern")
        return pattern
    if not _compiler.isstring(pattern):
        raise TypeError("first argument must be string or compiled pattern")
    if flags & T:
        import warnings
        warnings.warn("The re.TEMPLATE/re.T flag is deprecated "
                  "as it is an undocumented flag "
                  "without an obvious purpose. "
                  "Don't use it.",
                  DeprecationWarning)
    p = _compiler.compile(pattern, flags)
    if not (flags & DEBUG):
        if len(_cache) >= _MAXCACHE:
            # Drop the oldest item
            try:
                del _cache[next(iter(_cache))]
            except (StopIteration, RuntimeError, KeyError):
                pass
        _cache[type(pattern), pattern, flags] = p
    return p

@functools.lru_cache(_MAXCACHE)
def _compile_repl(repl, pattern):
    # internal: compile replacement pattern
    return _parser.parse_template(repl, pattern)

def _expand(pattern, match, template):
    # internal: Match.expand implementation hook
    template = _parser.parse_template(template, pattern)
    return _parser.expand_template(template, match)

def _subx(pattern, template):
    # internal: Pattern.sub/subn implementation helper
    template = _compile_repl(template, pattern)
    if not template[0] and len(template[1]) == 1:
        # literal replacement
        return template[1][0]
    def filter(match, template=template):
        return _parser.expand_template(template, match)
    return filter

# register myself for pickling

import copyreg

def _pickle(p):
    return _compile, (p.pattern, p.flags)

copyreg.pickle(Pattern, _pickle, _compile)

# --------------------------------------------------------------------
# experimental stuff (see python-dev discussions for details)

class Scanner:
    def __init__(self, lexicon, flags=0):
        from ._constants import BRANCH, SUBPATTERN
        if isinstance(flags, RegexFlag):
            flags = flags.value
        self.lexicon = lexicon
        # combine phrases into a compound pattern
        p = []
        s = _parser.State()
        s.flags = flags
        for phrase, action in lexicon:
            gid = s.opengroup()
            p.append(_parser.SubPattern(s, [
                (SUBPATTERN, (gid, 0, 0, _parser.parse(phrase, flags))),
                ]))
            s.closegroup(gid, p[-1])
        p = _parser.SubPattern(s, [(BRANCH, (None, p))])
        self.scanner = _compiler.compile(p)
    def scan(self, string):
        result = []
        append = result.append
        match = self.scanner.scanner(string).match
        i = 0
        while True:
            m = match()
            if not m:
                break
            j = m.end()
            if i == j:
                break
            action = self.lexicon[m.lastindex-1][1]
            if callable(action):
                self.match = m
                action = action(self, m.group())
            if action is not None:
                append(action)
            i = j
        return result, string[i:]
PKV*]>�+FF_casefix.pynu�[���# Auto-generated by Tools/scripts/generate_re_casefix.py.

# Maps the code of lowercased character to codes of different lowercased
# characters which have the same uppercase.
_EXTRA_CASES = {
    # LATIN SMALL LETTER I: LATIN SMALL LETTER DOTLESS I
    0x0069: (0x0131,), # 'i': 'ı'
    # LATIN SMALL LETTER S: LATIN SMALL LETTER LONG S
    0x0073: (0x017f,), # 's': 'ſ'
    # MICRO SIGN: GREEK SMALL LETTER MU
    0x00b5: (0x03bc,), # 'µ': 'μ'
    # LATIN SMALL LETTER DOTLESS I: LATIN SMALL LETTER I
    0x0131: (0x0069,), # 'ı': 'i'
    # LATIN SMALL LETTER LONG S: LATIN SMALL LETTER S
    0x017f: (0x0073,), # 'ſ': 's'
    # COMBINING GREEK YPOGEGRAMMENI: GREEK SMALL LETTER IOTA, GREEK PROSGEGRAMMENI
    0x0345: (0x03b9, 0x1fbe), # '\u0345': 'ιι'
    # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS: GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
    0x0390: (0x1fd3,), # 'ΐ': 'ΐ'
    # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS: GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
    0x03b0: (0x1fe3,), # 'ΰ': 'ΰ'
    # GREEK SMALL LETTER BETA: GREEK BETA SYMBOL
    0x03b2: (0x03d0,), # 'β': 'ϐ'
    # GREEK SMALL LETTER EPSILON: GREEK LUNATE EPSILON SYMBOL
    0x03b5: (0x03f5,), # 'ε': 'ϵ'
    # GREEK SMALL LETTER THETA: GREEK THETA SYMBOL
    0x03b8: (0x03d1,), # 'θ': 'ϑ'
    # GREEK SMALL LETTER IOTA: COMBINING GREEK YPOGEGRAMMENI, GREEK PROSGEGRAMMENI
    0x03b9: (0x0345, 0x1fbe), # 'ι': '\u0345ι'
    # GREEK SMALL LETTER KAPPA: GREEK KAPPA SYMBOL
    0x03ba: (0x03f0,), # 'κ': 'ϰ'
    # GREEK SMALL LETTER MU: MICRO SIGN
    0x03bc: (0x00b5,), # 'μ': 'µ'
    # GREEK SMALL LETTER PI: GREEK PI SYMBOL
    0x03c0: (0x03d6,), # 'π': 'ϖ'
    # GREEK SMALL LETTER RHO: GREEK RHO SYMBOL
    0x03c1: (0x03f1,), # 'ρ': 'ϱ'
    # GREEK SMALL LETTER FINAL SIGMA: GREEK SMALL LETTER SIGMA
    0x03c2: (0x03c3,), # 'ς': 'σ'
    # GREEK SMALL LETTER SIGMA: GREEK SMALL LETTER FINAL SIGMA
    0x03c3: (0x03c2,), # 'σ': 'ς'
    # GREEK SMALL LETTER PHI: GREEK PHI SYMBOL
    0x03c6: (0x03d5,), # 'φ': 'ϕ'
    # GREEK BETA SYMBOL: GREEK SMALL LETTER BETA
    0x03d0: (0x03b2,), # 'ϐ': 'β'
    # GREEK THETA SYMBOL: GREEK SMALL LETTER THETA
    0x03d1: (0x03b8,), # 'ϑ': 'θ'
    # GREEK PHI SYMBOL: GREEK SMALL LETTER PHI
    0x03d5: (0x03c6,), # 'ϕ': 'φ'
    # GREEK PI SYMBOL: GREEK SMALL LETTER PI
    0x03d6: (0x03c0,), # 'ϖ': 'π'
    # GREEK KAPPA SYMBOL: GREEK SMALL LETTER KAPPA
    0x03f0: (0x03ba,), # 'ϰ': 'κ'
    # GREEK RHO SYMBOL: GREEK SMALL LETTER RHO
    0x03f1: (0x03c1,), # 'ϱ': 'ρ'
    # GREEK LUNATE EPSILON SYMBOL: GREEK SMALL LETTER EPSILON
    0x03f5: (0x03b5,), # 'ϵ': 'ε'
    # CYRILLIC SMALL LETTER VE: CYRILLIC SMALL LETTER ROUNDED VE
    0x0432: (0x1c80,), # 'в': 'ᲀ'
    # CYRILLIC SMALL LETTER DE: CYRILLIC SMALL LETTER LONG-LEGGED DE
    0x0434: (0x1c81,), # 'д': 'ᲁ'
    # CYRILLIC SMALL LETTER O: CYRILLIC SMALL LETTER NARROW O
    0x043e: (0x1c82,), # 'о': 'ᲂ'
    # CYRILLIC SMALL LETTER ES: CYRILLIC SMALL LETTER WIDE ES
    0x0441: (0x1c83,), # 'с': 'ᲃ'
    # CYRILLIC SMALL LETTER TE: CYRILLIC SMALL LETTER TALL TE, CYRILLIC SMALL LETTER THREE-LEGGED TE
    0x0442: (0x1c84, 0x1c85), # 'т': 'ᲄᲅ'
    # CYRILLIC SMALL LETTER HARD SIGN: CYRILLIC SMALL LETTER TALL HARD SIGN
    0x044a: (0x1c86,), # 'ъ': 'ᲆ'
    # CYRILLIC SMALL LETTER YAT: CYRILLIC SMALL LETTER TALL YAT
    0x0463: (0x1c87,), # 'ѣ': 'ᲇ'
    # CYRILLIC SMALL LETTER ROUNDED VE: CYRILLIC SMALL LETTER VE
    0x1c80: (0x0432,), # 'ᲀ': 'в'
    # CYRILLIC SMALL LETTER LONG-LEGGED DE: CYRILLIC SMALL LETTER DE
    0x1c81: (0x0434,), # 'ᲁ': 'д'
    # CYRILLIC SMALL LETTER NARROW O: CYRILLIC SMALL LETTER O
    0x1c82: (0x043e,), # 'ᲂ': 'о'
    # CYRILLIC SMALL LETTER WIDE ES: CYRILLIC SMALL LETTER ES
    0x1c83: (0x0441,), # 'ᲃ': 'с'
    # CYRILLIC SMALL LETTER TALL TE: CYRILLIC SMALL LETTER TE, CYRILLIC SMALL LETTER THREE-LEGGED TE
    0x1c84: (0x0442, 0x1c85), # 'ᲄ': 'тᲅ'
    # CYRILLIC SMALL LETTER THREE-LEGGED TE: CYRILLIC SMALL LETTER TE, CYRILLIC SMALL LETTER TALL TE
    0x1c85: (0x0442, 0x1c84), # 'ᲅ': 'тᲄ'
    # CYRILLIC SMALL LETTER TALL HARD SIGN: CYRILLIC SMALL LETTER HARD SIGN
    0x1c86: (0x044a,), # 'ᲆ': 'ъ'
    # CYRILLIC SMALL LETTER TALL YAT: CYRILLIC SMALL LETTER YAT
    0x1c87: (0x0463,), # 'ᲇ': 'ѣ'
    # CYRILLIC SMALL LETTER UNBLENDED UK: CYRILLIC SMALL LETTER MONOGRAPH UK
    0x1c88: (0xa64b,), # 'ᲈ': 'ꙋ'
    # LATIN SMALL LETTER S WITH DOT ABOVE: LATIN SMALL LETTER LONG S WITH DOT ABOVE
    0x1e61: (0x1e9b,), # 'ṡ': 'ẛ'
    # LATIN SMALL LETTER LONG S WITH DOT ABOVE: LATIN SMALL LETTER S WITH DOT ABOVE
    0x1e9b: (0x1e61,), # 'ẛ': 'ṡ'
    # GREEK PROSGEGRAMMENI: COMBINING GREEK YPOGEGRAMMENI, GREEK SMALL LETTER IOTA
    0x1fbe: (0x0345, 0x03b9), # 'ι': '\u0345ι'
    # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA: GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
    0x1fd3: (0x0390,), # 'ΐ': 'ΐ'
    # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA: GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
    0x1fe3: (0x03b0,), # 'ΰ': 'ΰ'
    # CYRILLIC SMALL LETTER MONOGRAPH UK: CYRILLIC SMALL LETTER UNBLENDED UK
    0xa64b: (0x1c88,), # 'ꙋ': 'ᲈ'
    # LATIN SMALL LIGATURE LONG S T: LATIN SMALL LIGATURE ST
    0xfb05: (0xfb06,), # 'ſt': 'st'
    # LATIN SMALL LIGATURE ST: LATIN SMALL LIGATURE LONG S T
    0xfb06: (0xfb05,), # 'st': 'ſt'
}
PKV*]��RR,__pycache__/_constants.cpython-311.opt-1.pycnu�[����

�����#����dZdZddlmZmZGd�de��ZGd�de��Zeed��Zd	�Z	e	d
�Z
e
dd�=e	d
ddddddddddd��Ze	dddddddd d!d"d#d$d%d&d'd(d)d*��Ze
eeeiZe
eeeiZe
eeeiZeeeeiZeeee iZ!ee"ee#iZ$e%e%e&e&e'e'e(e(e)e*e+e,e-e-e.e.iZ/e%e0e&e1e'e2e(e3e)e4e+e5e-e6e.e7iZ8d+Z9d,Z:d-Z;d.Z<d/Z=d0Z>d1Z?d2Z@d3ZAd+ZBd,ZCd-ZDdS)4zInternal support module for sreiNJ4�)�	MAXREPEAT�	MAXGROUPSc�(��eZdZdZdZd�fd�	Z�xZS)�erroraiException raised for invalid regular expressions.

    Attributes:

        msg: The unformatted error message
        pattern: The regular expression pattern
        pos: The index in the pattern where compilation failed (may be None)
        lineno: The line corresponding to pos (may be None)
        colno: The column corresponding to pos (may be None)
    �reNc���||_||_||_|�x|�vd||fz}t|t��rd}nd}|�|d|��dz|_||�|d|��z
|_||vrd||j|jfz}ndx|_|_t���
|��dS)Nz%s at position %d�
�
r�z%s (line %d, column %d))�msg�pattern�pos�
isinstance�str�count�lineno�rfind�colno�super�__init__)�selfrr
r�newline�	__class__s     ��8/opt/alt/python-internal/lib/python3.11/re/_constants.pyrzerror.__init__%s���������������3�?�%��c�
�2�C��'�3�'�'�
 ������!�-�-���C�8�8�1�<�D�K��w�}�}�W�a��=�=�=�D�J��'�!�!�/�3���T�Z�2P�P���'+�+�D�K�$�*�
�����������)NN)�__name__�
__module__�__qualname__�__doc__r�
__classcell__�rs@rrrsN�������	�	��J����������rrc�(��eZdZ�fd�Zd�ZdZ�xZS)�_NamedIntConstantc�h��tt|���||��}||_|S�N)rr#�__new__�name)�cls�valuer'rrs    �rr&z_NamedIntConstant.__new__9s/����&��,�,�4�4�S�%�@�@����	��rc��|jSr%�r')rs r�__repr__z_NamedIntConstant.__repr__>s
���y�rN)rrrr&r,�
__reduce__r r!s@rr#r#8sB������������
����J�J�J�J�Jrr#rc��d�t|��D��}t���d�|D����|S)Nc�4�g|]\}}t||����S�)r#)�.0�ir's   r�
<listcomp>z_makecodes.<locals>.<listcomp>Fs'��H�H�H�G�A�t�
�q�$�
'�
'�H�H�Hrc��i|]
}|j|��Sr0r+)r1�items  r�
<dictcomp>z_makecodes.<locals>.<dictcomp>Gs��8�8�8�$�d�i��8�8�8r)�	enumerate�globals�update)�names�itemss  r�
_makecodesr<EsI��H�H�y��7G�7G�H�H�H�E��I�I���8�8�%�8�8�8�9�9�9��Lr)-�FAILURE�SUCCESS�ANY�ANY_ALL�ASSERT�
ASSERT_NOT�AT�BRANCH�CATEGORY�CHARSET�
BIGCHARSET�GROUPREF�GROUPREF_EXISTS�IN�INFO�JUMP�LITERAL�MARK�	MAX_UNTIL�	MIN_UNTIL�NOT_LITERAL�NEGATE�RANGE�REPEAT�
REPEAT_ONE�
SUBPATTERN�MIN_REPEAT_ONE�ATOMIC_GROUP�POSSESSIVE_REPEAT�POSSESSIVE_REPEAT_ONE�GROUPREF_IGNORE�	IN_IGNORE�LITERAL_IGNORE�NOT_LITERAL_IGNORE�GROUPREF_LOC_IGNORE�
IN_LOC_IGNORE�LITERAL_LOC_IGNORE�NOT_LITERAL_LOC_IGNORE�GROUPREF_UNI_IGNORE�
IN_UNI_IGNORE�LITERAL_UNI_IGNORE�NOT_LITERAL_UNI_IGNORE�RANGE_UNI_IGNORE�
MIN_REPEAT�
MAX_REPEAT���N�AT_BEGINNING�AT_BEGINNING_LINE�AT_BEGINNING_STRING�AT_BOUNDARY�AT_NON_BOUNDARY�AT_END�AT_END_LINE�
AT_END_STRING�AT_LOC_BOUNDARY�AT_LOC_NON_BOUNDARY�AT_UNI_BOUNDARY�AT_UNI_NON_BOUNDARY�CATEGORY_DIGIT�CATEGORY_NOT_DIGIT�CATEGORY_SPACE�CATEGORY_NOT_SPACE�
CATEGORY_WORD�CATEGORY_NOT_WORD�CATEGORY_LINEBREAK�CATEGORY_NOT_LINEBREAK�CATEGORY_LOC_WORD�CATEGORY_LOC_NOT_WORD�CATEGORY_UNI_DIGIT�CATEGORY_UNI_NOT_DIGIT�CATEGORY_UNI_SPACE�CATEGORY_UNI_NOT_SPACE�CATEGORY_UNI_WORD�CATEGORY_UNI_NOT_WORD�CATEGORY_UNI_LINEBREAK�CATEGORY_UNI_NOT_LINEBREAKr����� �@��)Er�MAGIC�_srerr�	Exceptionr�intr#r<�OPCODES�ATCODES�CHCODESrMr]rQr^�	OP_IGNORErarb�OP_LOCALE_IGNORErerf�OP_UNICODE_IGNORErkrlrprq�AT_MULTILINErnrsrort�	AT_LOCALErurv�
AT_UNICODErwrxryrzr{rr|r�r}r~�	CH_LOCALEr�r�r�r�r�r�r�r��
CH_UNICODE�SRE_FLAG_TEMPLATE�SRE_FLAG_IGNORECASE�SRE_FLAG_LOCALE�SRE_FLAG_MULTILINE�SRE_FLAG_DOTALL�SRE_FLAG_UNICODE�SRE_FLAG_VERBOSE�SRE_FLAG_DEBUG�SRE_FLAG_ASCII�SRE_INFO_PREFIX�SRE_INFO_LITERAL�SRE_INFO_CHARSETr0rr�<module>r�s|��&�%�	��%�%�%�%�%�%�%�%�
�����I����B	�	�	�	�	��	�	�	�
��i��5�5�	�����*�0�0��b�B�C�C�L��*��'�)>��$��m�_��,��,�����*��*��*��(��2��0��2��2��0��:����"�^��#�
�	��
��'����
��'����#�
�K������(�
�	����(��
��N��*��N��*��$��,��*��2�	
�	��&��.��&��.��$��,��.��6�	�
��������������������������rPKV*]F�G��,__pycache__/_constants.cpython-311.opt-2.pycnu�[����

�����#����	dZddlmZmZGd�de��ZGd�de��Zeed��Zd�Zed	�Z	e	d
d�=edd
dddddddddd��Z
eddddddddd d!d"d#d$d%d&d'd(d)��Zee
eeiZeeeeiZeeeeiZeeeeiZeeeeiZ ee!ee"iZ#e$e$e%e%e&e&e'e'e(e)e*e+e,e,e-e-iZ.e$e/e%e0e&e1e'e2e(e3e*e4e,e5e-e6iZ7d*Z8d+Z9d,Z:d-Z;d.Z<d/Z=d0Z>d1Z?d2Z@d*ZAd+ZBd,ZCdS)3iNJ4�)�	MAXREPEAT�	MAXGROUPSc�&��eZdZ	dZd�fd�	Z�xZS)�error�reNc���||_||_||_|�x|�vd||fz}t|t��rd}nd}|�|d|��dz|_||�|d|��z
|_||vrd||j|jfz}ndx|_|_t���
|��dS)Nz%s at position %d�
�
r�z%s (line %d, column %d))�msg�pattern�pos�
isinstance�str�count�lineno�rfind�colno�super�__init__)�selfrr
r�newline�	__class__s     ��8/opt/alt/python-internal/lib/python3.11/re/_constants.pyrzerror.__init__%s���������������3�?�%��c�
�2�C��'�3�'�'�
 ������!�-�-���C�8�8�1�<�D�K��w�}�}�W�a��=�=�=�D�J��'�!�!�/�3���T�Z�2P�P���'+�+�D�K�$�*�
�����������)NN)�__name__�
__module__�__qualname__r�
__classcell__�rs@rrrsI�������	��J����������rrc�(��eZdZ�fd�Zd�ZdZ�xZS)�_NamedIntConstantc�h��tt|���||��}||_|S�N)rr"�__new__�name)�cls�valuer&rrs    �rr%z_NamedIntConstant.__new__9s/����&��,�,�4�4�S�%�@�@����	��rc��|jSr$�r&)rs r�__repr__z_NamedIntConstant.__repr__>s
���y�rN)rrrr%r+�
__reduce__rr s@rr"r"8sB������������
����J�J�J�J�Jrr"rc��d�t|��D��}t���d�|D����|S)Nc�4�g|]\}}t||����S�)r")�.0�ir&s   r�
<listcomp>z_makecodes.<locals>.<listcomp>Fs'��H�H�H�G�A�t�
�q�$�
'�
'�H�H�Hrc��i|]
}|j|��Sr/r*)r0�items  r�
<dictcomp>z_makecodes.<locals>.<dictcomp>Gs��8�8�8�$�d�i��8�8�8r)�	enumerate�globals�update)�names�itemss  r�
_makecodesr;EsI��H�H�y��7G�7G�H�H�H�E��I�I���8�8�%�8�8�8�9�9�9��Lr)-�FAILURE�SUCCESS�ANY�ANY_ALL�ASSERT�
ASSERT_NOT�AT�BRANCH�CATEGORY�CHARSET�
BIGCHARSET�GROUPREF�GROUPREF_EXISTS�IN�INFO�JUMP�LITERAL�MARK�	MAX_UNTIL�	MIN_UNTIL�NOT_LITERAL�NEGATE�RANGE�REPEAT�
REPEAT_ONE�
SUBPATTERN�MIN_REPEAT_ONE�ATOMIC_GROUP�POSSESSIVE_REPEAT�POSSESSIVE_REPEAT_ONE�GROUPREF_IGNORE�	IN_IGNORE�LITERAL_IGNORE�NOT_LITERAL_IGNORE�GROUPREF_LOC_IGNORE�
IN_LOC_IGNORE�LITERAL_LOC_IGNORE�NOT_LITERAL_LOC_IGNORE�GROUPREF_UNI_IGNORE�
IN_UNI_IGNORE�LITERAL_UNI_IGNORE�NOT_LITERAL_UNI_IGNORE�RANGE_UNI_IGNORE�
MIN_REPEAT�
MAX_REPEAT���N�AT_BEGINNING�AT_BEGINNING_LINE�AT_BEGINNING_STRING�AT_BOUNDARY�AT_NON_BOUNDARY�AT_END�AT_END_LINE�
AT_END_STRING�AT_LOC_BOUNDARY�AT_LOC_NON_BOUNDARY�AT_UNI_BOUNDARY�AT_UNI_NON_BOUNDARY�CATEGORY_DIGIT�CATEGORY_NOT_DIGIT�CATEGORY_SPACE�CATEGORY_NOT_SPACE�
CATEGORY_WORD�CATEGORY_NOT_WORD�CATEGORY_LINEBREAK�CATEGORY_NOT_LINEBREAK�CATEGORY_LOC_WORD�CATEGORY_LOC_NOT_WORD�CATEGORY_UNI_DIGIT�CATEGORY_UNI_NOT_DIGIT�CATEGORY_UNI_SPACE�CATEGORY_UNI_NOT_SPACE�CATEGORY_UNI_WORD�CATEGORY_UNI_NOT_WORD�CATEGORY_UNI_LINEBREAK�CATEGORY_UNI_NOT_LINEBREAKr����� �@��)D�MAGIC�_srerr�	Exceptionr�intr"r;�OPCODES�ATCODES�CHCODESrLr\rPr]�	OP_IGNOREr`ra�OP_LOCALE_IGNORErdre�OP_UNICODE_IGNORErjrkrorp�AT_MULTILINErmrrrnrs�	AT_LOCALErtru�
AT_UNICODErvrwrxryrzr~r{rr|r}�	CH_LOCALEr�r�r�r�r�r�r�r��
CH_UNICODE�SRE_FLAG_TEMPLATE�SRE_FLAG_IGNORECASE�SRE_FLAG_LOCALE�SRE_FLAG_MULTILINE�SRE_FLAG_DOTALL�SRE_FLAG_UNICODE�SRE_FLAG_VERBOSE�SRE_FLAG_DEBUG�SRE_FLAG_ASCII�SRE_INFO_PREFIX�SRE_INFO_LITERAL�SRE_INFO_CHARSETr/rr�<module>r�sy��&�	��%�%�%�%�%�%�%�%�
�����I����B	�	�	�	�	��	�	�	�
��i��5�5�	�����*�0�0��b�B�C�C�L��*��'�)>��$��m�_��,��,�����*��*��*��(��2��0��2��2��0��:����"�^��#�
�	��
��'����
��'����#�
�K������(�
�	����(��
��N��*��N��*��$��,��*��2�	
�	��&��.��&��.��$��,��.��6�	�
��������������������������rPKV*]��RR&__pycache__/_constants.cpython-311.pycnu�[����

�����#����dZdZddlmZmZGd�de��ZGd�de��Zeed��Zd	�Z	e	d
�Z
e
dd�=e	d
ddddddddddd��Ze	dddddddd d!d"d#d$d%d&d'd(d)d*��Ze
eeeiZe
eeeiZe
eeeiZeeeeiZeeee iZ!ee"ee#iZ$e%e%e&e&e'e'e(e(e)e*e+e,e-e-e.e.iZ/e%e0e&e1e'e2e(e3e)e4e+e5e-e6e.e7iZ8d+Z9d,Z:d-Z;d.Z<d/Z=d0Z>d1Z?d2Z@d3ZAd+ZBd,ZCd-ZDdS)4zInternal support module for sreiNJ4�)�	MAXREPEAT�	MAXGROUPSc�(��eZdZdZdZd�fd�	Z�xZS)�erroraiException raised for invalid regular expressions.

    Attributes:

        msg: The unformatted error message
        pattern: The regular expression pattern
        pos: The index in the pattern where compilation failed (may be None)
        lineno: The line corresponding to pos (may be None)
        colno: The column corresponding to pos (may be None)
    �reNc���||_||_||_|�x|�vd||fz}t|t��rd}nd}|�|d|��dz|_||�|d|��z
|_||vrd||j|jfz}ndx|_|_t���
|��dS)Nz%s at position %d�
�
r�z%s (line %d, column %d))�msg�pattern�pos�
isinstance�str�count�lineno�rfind�colno�super�__init__)�selfrr
r�newline�	__class__s     ��8/opt/alt/python-internal/lib/python3.11/re/_constants.pyrzerror.__init__%s���������������3�?�%��c�
�2�C��'�3�'�'�
 ������!�-�-���C�8�8�1�<�D�K��w�}�}�W�a��=�=�=�D�J��'�!�!�/�3���T�Z�2P�P���'+�+�D�K�$�*�
�����������)NN)�__name__�
__module__�__qualname__�__doc__r�
__classcell__�rs@rrrsN�������	�	��J����������rrc�(��eZdZ�fd�Zd�ZdZ�xZS)�_NamedIntConstantc�h��tt|���||��}||_|S�N)rr#�__new__�name)�cls�valuer'rrs    �rr&z_NamedIntConstant.__new__9s/����&��,�,�4�4�S�%�@�@����	��rc��|jSr%�r')rs r�__repr__z_NamedIntConstant.__repr__>s
���y�rN)rrrr&r,�
__reduce__r r!s@rr#r#8sB������������
����J�J�J�J�Jrr#rc��d�t|��D��}t���d�|D����|S)Nc�4�g|]\}}t||����S�)r#)�.0�ir's   r�
<listcomp>z_makecodes.<locals>.<listcomp>Fs'��H�H�H�G�A�t�
�q�$�
'�
'�H�H�Hrc��i|]
}|j|��Sr0r+)r1�items  r�
<dictcomp>z_makecodes.<locals>.<dictcomp>Gs��8�8�8�$�d�i��8�8�8r)�	enumerate�globals�update)�names�itemss  r�
_makecodesr<EsI��H�H�y��7G�7G�H�H�H�E��I�I���8�8�%�8�8�8�9�9�9��Lr)-�FAILURE�SUCCESS�ANY�ANY_ALL�ASSERT�
ASSERT_NOT�AT�BRANCH�CATEGORY�CHARSET�
BIGCHARSET�GROUPREF�GROUPREF_EXISTS�IN�INFO�JUMP�LITERAL�MARK�	MAX_UNTIL�	MIN_UNTIL�NOT_LITERAL�NEGATE�RANGE�REPEAT�
REPEAT_ONE�
SUBPATTERN�MIN_REPEAT_ONE�ATOMIC_GROUP�POSSESSIVE_REPEAT�POSSESSIVE_REPEAT_ONE�GROUPREF_IGNORE�	IN_IGNORE�LITERAL_IGNORE�NOT_LITERAL_IGNORE�GROUPREF_LOC_IGNORE�
IN_LOC_IGNORE�LITERAL_LOC_IGNORE�NOT_LITERAL_LOC_IGNORE�GROUPREF_UNI_IGNORE�
IN_UNI_IGNORE�LITERAL_UNI_IGNORE�NOT_LITERAL_UNI_IGNORE�RANGE_UNI_IGNORE�
MIN_REPEAT�
MAX_REPEAT���N�AT_BEGINNING�AT_BEGINNING_LINE�AT_BEGINNING_STRING�AT_BOUNDARY�AT_NON_BOUNDARY�AT_END�AT_END_LINE�
AT_END_STRING�AT_LOC_BOUNDARY�AT_LOC_NON_BOUNDARY�AT_UNI_BOUNDARY�AT_UNI_NON_BOUNDARY�CATEGORY_DIGIT�CATEGORY_NOT_DIGIT�CATEGORY_SPACE�CATEGORY_NOT_SPACE�
CATEGORY_WORD�CATEGORY_NOT_WORD�CATEGORY_LINEBREAK�CATEGORY_NOT_LINEBREAK�CATEGORY_LOC_WORD�CATEGORY_LOC_NOT_WORD�CATEGORY_UNI_DIGIT�CATEGORY_UNI_NOT_DIGIT�CATEGORY_UNI_SPACE�CATEGORY_UNI_NOT_SPACE�CATEGORY_UNI_WORD�CATEGORY_UNI_NOT_WORD�CATEGORY_UNI_LINEBREAK�CATEGORY_UNI_NOT_LINEBREAKr����� �@��)Er�MAGIC�_srerr�	Exceptionr�intr#r<�OPCODES�ATCODES�CHCODESrMr]rQr^�	OP_IGNORErarb�OP_LOCALE_IGNORErerf�OP_UNICODE_IGNORErkrlrprq�AT_MULTILINErnrsrort�	AT_LOCALErurv�
AT_UNICODErwrxryrzr{rr|r�r}r~�	CH_LOCALEr�r�r�r�r�r�r�r��
CH_UNICODE�SRE_FLAG_TEMPLATE�SRE_FLAG_IGNORECASE�SRE_FLAG_LOCALE�SRE_FLAG_MULTILINE�SRE_FLAG_DOTALL�SRE_FLAG_UNICODE�SRE_FLAG_VERBOSE�SRE_FLAG_DEBUG�SRE_FLAG_ASCII�SRE_INFO_PREFIX�SRE_INFO_LITERAL�SRE_INFO_CHARSETr0rr�<module>r�s|��&�%�	��%�%�%�%�%�%�%�%�
�����I����B	�	�	�	�	��	�	�	�
��i��5�5�	�����*�0�0��b�B�C�C�L��*��'�)>��$��m�_��,��,�����*��*��*��(��2��0��2��2��0��:����"�^��#�
�	��
��'����
��'����#�
�K������(�
�	����(��
��N��*��N��*��$��,��*��2�	
�	��&��.��&��.��$��,��.��6�	�
��������������������������rPKV*]��_ΆK�K$__pycache__/__init__.cpython-311.pycnu�[����

��0cL�s��V�dZddlZddlmZmZddlZgd�ZdZejej	ej
ej���Gd�d	������Zej
Z
d!d
�Zd!d�Zd!d�Zd"d
�Zd"d�Zd"d�Zd!d�Zd!d�Zd!d�Zd�Zd!d�Zd�dD��Zd�Zeejdd����Zeejdd���d����ZiZdZd�Z ej!e��d���Z"d�Z#d�Z$ddl%Z%d�Z&e%j'ee&e ��Gd�d ��Z(dS)#a�Support for regular expressions (RE).

This module provides regular expression matching operations similar to
those found in Perl.  It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range.

Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves.  You can
concatenate ordinary characters, so last matches the string 'last'.

The special characters are:
    "."      Matches any character except a newline.
    "^"      Matches the start of the string.
    "$"      Matches the end of the string or just before the newline at
             the end of the string.
    "*"      Matches 0 or more (greedy) repetitions of the preceding RE.
             Greedy means that it will match as many repetitions as possible.
    "+"      Matches 1 or more (greedy) repetitions of the preceding RE.
    "?"      Matches 0 or 1 (greedy) of the preceding RE.
    *?,+?,?? Non-greedy versions of the previous three special characters.
    {m,n}    Matches from m to n repetitions of the preceding RE.
    {m,n}?   Non-greedy version of the above.
    "\\"     Either escapes special characters or signals a special sequence.
    []       Indicates a set of characters.
             A "^" as the first character indicates a complementing set.
    "|"      A|B, creates an RE that will match either A or B.
    (...)    Matches the RE inside the parentheses.
             The contents can be retrieved or matched later in the string.
    (?aiLmsux) The letters set the corresponding flags defined below.
    (?:...)  Non-grouping version of regular parentheses.
    (?P<name>...) The substring matched by the group is accessible by name.
    (?P=name)     Matches the text matched earlier by the group named name.
    (?#...)  A comment; ignored.
    (?=...)  Matches if ... matches next, but doesn't consume the string.
    (?!...)  Matches if ... doesn't match next.
    (?<=...) Matches if preceded by ... (must be fixed length).
    (?<!...) Matches if not preceded by ... (must be fixed length).
    (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
                       the (optional) no pattern otherwise.

The special sequences consist of "\\" and a character from the list
below.  If the ordinary character is not on the list, then the
resulting RE will match the second character.
    \number  Matches the contents of the group of the same number.
    \A       Matches only at the start of the string.
    \Z       Matches only at the end of the string.
    \b       Matches the empty string, but only at the start or end of a word.
    \B       Matches the empty string, but not at the start or end of a word.
    \d       Matches any decimal digit; equivalent to the set [0-9] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode digits.
    \D       Matches any non-digit character; equivalent to [^\d].
    \s       Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode whitespace characters.
    \S       Matches any non-whitespace character; equivalent to [^\s].
    \w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
             in bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the
             range of Unicode alphanumeric characters (letters plus digits
             plus underscore).
             With LOCALE, it will match the set [0-9_] plus characters defined
             as letters for the current locale.
    \W       Matches the complement of \w.
    \\       Matches a literal backslash.

This module exports the following functions:
    match     Match a regular expression pattern to the beginning of a string.
    fullmatch Match a regular expression pattern to all of a string.
    search    Search a string for the presence of a pattern.
    sub       Substitute occurrences of a pattern found in a string.
    subn      Same as sub, but also return the number of substitutions made.
    split     Split a string by the occurrences of a pattern.
    findall   Find all occurrences of a pattern in a string.
    finditer  Return an iterator yielding a Match object for each match.
    compile   Compile a pattern into a Pattern object.
    purge     Clear the regular expression cache.
    escape    Backslash all non-alphanumerics in a string.

Each function other than purge and escape can take an optional 'flags' argument
consisting of one or more of the following module constants, joined by "|".
A, L, and U are mutually exclusive.
    A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D
                   match the corresponding ASCII character categories
                   (rather than the whole Unicode categories, which is the
                   default).
                   For bytes patterns, this flag is the only available
                   behaviour and needn't be specified.
    I  IGNORECASE  Perform case-insensitive matching.
    L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
    M  MULTILINE   "^" matches the beginning of lines (after a newline)
                   as well as the string.
                   "$" matches the end of lines (before a newline) as well
                   as the end of the string.
    S  DOTALL      "." matches any character at all, including the newline.
    X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
    U  UNICODE     For compatibility only. Ignored for string patterns (it
                   is the default), and forbidden for bytes patterns.

This module also defines an exception 'error'.

�N�)�	_compiler�_parser)�match�	fullmatch�search�sub�subn�split�findall�finditer�compile�purge�template�escape�error�Pattern�Match�A�I�L�M�S�X�U�ASCII�
IGNORECASE�LOCALE�	MULTILINE�DOTALL�VERBOSE�UNICODE�NOFLAG�	RegexFlagz2.2.1)�boundaryc���eZdZdZejxZZejxZ	Z
ejxZZ
ejxZZejxZZejxZZejxZZejxZZejZej Z e!Z"dS)r$rN)#�__name__�
__module__�__qualname__r#r�SRE_FLAG_ASCIIrr�SRE_FLAG_IGNORECASErr�SRE_FLAG_LOCALErr�SRE_FLAG_UNICODEr"r�SRE_FLAG_MULTILINErr�SRE_FLAG_DOTALLr r�SRE_FLAG_VERBOSEr!r�SRE_FLAG_TEMPLATE�TEMPLATE�T�SRE_FLAG_DEBUG�DEBUG�object�__str__�hex�_numeric_repr_���6/opt/alt/python-internal/lib/python3.11/re/__init__.pyr$r$�s��������F��(�(�E�A��2�2�J���*�*�F�Q��,�,�G�a��0�0�I���*�*�F�Q��,�,�G�a��.�.�H�q��$�E��n�G��N�N�Nr;r$c�H�t||���|��S)zqTry to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found.)�_compiler��pattern�string�flagss   r<rr�s"���G�U�#�#�)�)�&�1�1�1r;c�H�t||���|��S)zkTry to apply the pattern to all of the string, returning
    a Match object, or None if no match was found.)r>rr?s   r<rr�s"���G�U�#�#�-�-�f�5�5�5r;c�H�t||���|��S)ztScan through string looking for a match to the pattern, returning
    a Match object, or None if no match was found.)r>rr?s   r<rr�s"���G�U�#�#�*�*�6�2�2�2r;c�L�t||���|||��S)aZReturn 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.)r>r	�r@�replrA�countrBs     r<r	r	�s&���G�U�#�#�'�'��f�e�<�<�<r;c�L�t||���|||��S)a�Return a 2-tuple containing (new_string, number).
    new_string is the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in the source
    string by the replacement repl.  number is the number of
    substitutions that were made. 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.)r>r
rFs     r<r
r
�s&���G�U�#�#�(�(��v�u�=�=�=r;c�J�t||���||��S)a�Split the source string by the occurrences of the pattern,
    returning a list containing the resulting substrings.  If
    capturing parentheses are used in pattern, then the text of all
    groups in the pattern are also returned as part of the resulting
    list.  If maxsplit is nonzero, at most maxsplit splits occur,
    and the remainder of the string is returned as the final element
    of the list.)r>r)r@rA�maxsplitrBs    r<rr�s$���G�U�#�#�)�)�&�(�;�;�;r;c�H�t||���|��S)aReturn a list of all non-overlapping matches in the string.

    If one or more capturing 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.)r>rr?s   r<rr�s"���G�U�#�#�+�+�F�3�3�3r;c�H�t||���|��S)z�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.)r>r
r?s   r<r
r
�s"��
�G�U�#�#�,�,�V�4�4�4r;c�"�t||��S)zACompile a regular expression pattern, returning a Pattern object.)r>)r@rBs  r<rr�s���G�U�#�#�#r;c�j�t���t���dS)z#Clear the regular expression cachesN)�_cache�clear�
_compile_repl�cache_clearr:r;r<rr�s'��
�L�L�N�N�N��������r;c��ddl}|�dt��|���5|�dt��t||tz��cddd��S#1swxYwYdS)zBCompile a template pattern, returning a Pattern object, deprecatedrNz�The re.template() function is deprecated as it is an undocumented function without an obvious purpose. Use re.compile() instead.�ignore)�warnings�warn�DeprecationWarning�catch_warnings�simplefilterr>r3)r@rBrVs   r<rr�s����O�O�O��M�M�.�%�	&�&�&�

�	 �	 �	"�	"�*�*����h�(:�;�;�;����q��)�)�*�*�*�*�*�*�*�*�*�*�*�*����*�*�*�*�*�*s�3A4�4A8�;A8c�4�i|]}|dt|��z��S)�\)�chr)�.0�is  r<�
<dictcomp>r`�s$��R�R�R�1�a���A����R�R�Rr;s()[]{}?*+-|^$\.&~# 	

c���t|t��r|�t��St|d��}|�t���d��S)z0
    Escape special characters in a string.
    �latin1)�
isinstance�str�	translate�_special_chars_map�encode)r@s r<rr�s^���'�3���F�� � �!3�4�4�4��g�x�(�(��� � �!3�4�4�;�;�H�E�E�Er;�ic��t|t��r|j}	tt	|��||fS#t
$rYnwxYwt|t��r|rtd���|Stj	|��std���|tzrddl}|�
dt��tj||��}|t zs}t#t��t$krF	tt't)t����=n#t*t,t
f$rYnwxYw|tt	|��||f<|S)Nz5cannot process flags argument with a compiled patternz1first argument must be string or compiled patternrzoThe re.TEMPLATE/re.T flag is deprecated as it is an undocumented flag without an obvious purpose. Don't use it.)rcr$�valuerP�type�KeyErrorr�
ValueErrorr�isstring�	TypeErrorr3rVrWrXrr5�len�	_MAXCACHE�next�iter�
StopIteration�RuntimeError)r@rBrV�ps    r<r>r>sz���%��#�#�����
��d�7�m�m�W�e�3�4�4���
�
�
���
�����'�7�#�#���	I��G�I�I�
I�����g�&�&�M��K�L�L�L��q�y�&������
�
�"�%�		&�	&�	&�
	��'�5�)�)�A��E�M�2��v�;�;�)�#�#�
��4��V���-�-�.�.��!�<��:�
�
�
���
����01��t�G�}�}�g�u�,�-��Hs!�;�
A�A�<'D$�$D>�=D>c�,�tj||��S�N)r�parse_template)rGr@s  r<rRrR1s���!�$��0�0�0r;c�V�tj||��}tj||��Srx)rry�expand_template)r@rrs   r<�_expandr|6s'���%�h��8�8�H��"�8�U�3�3�3r;c��t||��}|ds't|d��dkr|ddS|fd�}|S)Nrrc�,�tj||��Srx)rr{)rrs  r<�filterz_subx.<locals>.filterAs���&�x��7�7�7r;)rRrp)r@rrs   r<�_subxr�;s]���X�w�/�/�H��A�;��3�x��{�+�+�q�0�0���{�1�~��'�8�8�8�8��Mr;c�,�t|j|jffSrx)r>r@rB)rvs r<�_pickler�Is���a�i���)�)�)r;c��eZdZdd�Zd�ZdS)�Scannerrc���ddlm}m}t|t��r|j}||_g}tj��}||_	|D]w\}}|�
��}	|�tj|||	ddtj
||��ffg����|�|	|d���xtj||d|ffg��}tj|��|_dS)Nr)�BRANCH�
SUBPATTERNr���)�
_constantsr�r�rcr$rj�lexiconr�StaterB�	opengroup�append�
SubPattern�parse�
closegrouprr�scanner)
�selfr�rBr�r�rv�s�phrase�action�gids
          r<�__init__zScanner.__init__Rs��2�2�2�2�2�2�2�2��e�Y�'�'�	 ��K�E�������M�O�O�����%�	%�	%�N�F�F��+�+�-�-�C�
�H�H�W�'���c�1�a���v�u�)E�)E�F�G�,���
�
�
�
�L�L��a��e�$�$�$�$���q�F�T�1�I�#6�"7�8�8�� �(��+�+����r;c�~�g}|j}|j�|��j}d}	|��}|snz|���}||krn_|j|jdz
d}t
|��r%||_|||�����}|�||��|}��|||d�fS)NrTr)r�r�r�endr��	lastindex�callable�group)	r�rA�resultr�rr_�m�jr�s	         r<�scanzScanner.scancs����������$�$�V�,�,�2��
��
	�����A��
�������A��A�v�v���\�!�+�a�-�0��3�F�����
1���
����a�g�g�i�i�0�0���!���v�����A�
	��v�a�b�b�z�!�!r;N�r)r'r(r)r�r�r:r;r<r�r�Qs7������,�,�,�,�""�"�"�"�"r;r�r�)rr))�__doc__�enumrhrr�	functools�__all__�__version__�global_enum�_simple_enum�IntFlag�KEEPr$rrrrr	r
rrr
rrrrfrrkrrrPrqr>�	lru_cacherRr|r��copyregr��pickler�r:r;r<�<module>r�s���"i�i�V���� � � � � � � � ����������������4�<�$�)�4�4�4�
�
�
�
�
�
�
�5�4���
� 	���
2�2�2�2�
6�6�6�6�
3�3�3�3�
=�=�=�=�	>�	>�	>�	>�<�<�<�<�4�4�4�4�5�5�5�5�$�$�$�$� � � �

*�
*�
*�
*�"S�R�0Q�R�R�R��F�F�F��$� �y� ��Q�'�'�
(�
(����
�Y�
�r�1�
%�
%�
+�
+�B�
/�
/�0�0��

���	�
�
�
�B���Y���1�1� ��1�4�4�4�
�������*�*�*����w���*�*�*�
%"�%"�%"�%"�%"�%"�%"�%"�%"�%"r;PKV*]�z�z+__pycache__/_compiler.cpython-311.opt-1.pycnu�[����

A��k������ �dZddlZddlmZddlTddlmZeehZ	e
ehZe
ehZe	eehzZeeeefeeeefeee
efiZejfd�Zd�Zd	�Z dd
�Z!ej"dzZ#de#zdz
Z$dZ%e#e&fd
�Z'd�Z(d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d�Z1d�Z2dd�Z3dS)zInternal support module for sre�N�)�_parser)�*)�_EXTRA_CASESc�*�||zr||z}||z|zS�N�)�flags�	add_flags�	del_flags�
TYPE_FLAGSs    �7/opt/alt/python-internal/lib/python3.11/re/_compiler.py�_combine_flagsrs-���:���
�*�����I��)��+�+�c
��|j}t}t}t}t}t
}d}	d}
d}|tzrL|tzsB|tzr tj
}	tj}
t}ntj
}	tj}
|D�]=\}}
||v�rP|tzs||��||
���,|tzr"|t|��||
���X|	|
��s||��||
���z|
|
��}|s"|t |��||����||vr"|t"|��||����|t$��||��}|d��|t&ur|t(��|f||zD]}|t*��||���|t,��||��|z
||<��[|t.ur�t1|
|	|
|��\}}|tzr|tzr|t2��n6|s|t.��n#|s|t4��n|t$��||��}|d��t7|||��||��|z
||<��|t8ur.|t:zr|t<����3|t8����E||v�rJ|t>zrtAd|�����tC|
d��r�|||d��||��}|d��||
d��||
d��tE||
d|��|tF��||��|z
||<��|||d��||��}|d��||
d��||
d��tE||
d|��||��|z
||<|||d�����|tHurr|
\}}}}|r!|tJ��||dz
dz��tE||tM|||����|r$|tJ��||dz
dzdz����|tNurZ|tN��||��}|d��tE||
|��|tF��||��|z
||<��r||vr
||�����||vr�||��||��}|d��|
ddkr|d��nW|
d�(��\}}|tRkrtAd���||krtAd���||��tE||
d|��|tF��||��|z
||<��Q|tTur�||��|tVzrtX�-|
|
��}
|tzrt\�-|
|
��}
n%|tzrt^�-|
|
��}
||
�����|t`ur�||��g}|j}|
dD]i}
||��}|d��tE||
|��|tb��|||����|d��||��|z
||<�j|t,��|D]}||��|z
||<����|tdurG||��|tzrtf|
}
n|tzr
th|
}
||
�����|tjurd|tzs||��n>|tzr|tl��n#|s|tn��n|tp��||
dz
����V|trur�||��||
ddz
��||��}|d��tE||
d|��|
drd|tb��||��}|d��||��|z
dz||<tE||
d|��||��|z
||<��||��|z
dz||<��-tAd|�����dS)Nrz(internal: unsupported template operator �rzlooks too much behindz(look-behind requires fixed-width patternz#internal: unsupported operand type ):�append�len�_LITERAL_CODES�_REPEATING_CODES�_SUCCESS_CODES�
_ASSERT_CODES�SRE_FLAG_IGNORECASE�SRE_FLAG_LOCALE�SRE_FLAG_UNICODE�_sre�unicode_iscased�unicode_tolowerr�
ascii_iscased�
ascii_tolower�OP_LOCALE_IGNORE�	OP_IGNORE�OP_UNICODE_IGNORE�
IN_UNI_IGNORE�NOT_LITERAL�NEGATE�LITERAL�FAILURE�IN�_optimize_charset�
IN_LOC_IGNORE�	IN_IGNORE�_compile_charset�ANY�SRE_FLAG_DOTALL�ANY_ALL�SRE_FLAG_TEMPLATE�error�_simple�_compile�SUCCESS�
SUBPATTERN�MARKr�ATOMIC_GROUP�getwidth�MAXCODE�AT�SRE_FLAG_MULTILINE�AT_MULTILINE�get�	AT_LOCALE�
AT_UNICODE�BRANCH�JUMP�CATEGORY�	CH_LOCALE�
CH_UNICODE�GROUPREF�GROUPREF_LOC_IGNORE�GROUPREF_IGNORE�GROUPREF_UNI_IGNORE�GROUPREF_EXISTS)�code�patternr
�emit�_len�
LITERAL_CODES�REPEATING_CODES�
SUCCESS_CODES�ASSERT_CODES�iscased�tolower�fixes�op�av�lo�skip�k�charset�hascased�grouprr�p�hi�tail�
tailappend�skipyes�skipnos                            rr4r4%s�	���;�D��D�"�M�&�O�"�M� �L��G��G��E��"�"�)�5�?�+B�)��#�#�	)��*�G��*�G� �E�E��(�G��(�G��^I�^I���B�
�����.�.�
3���R������R�������(�
3���%�b�)�*�*�*���R������W�R�[�[�
3���R������R������W�R�[�[���3��D��2��'�'�'��D��H�H�H�H��u�_�_��D�*�2�.�/�/�/��D��H�H�H�H��D��'�'�'��4��:�:�D�t�t�A�w�w�w��[�(�(���V���� �U�U�2�Y�.� � ����W�
�
�
���Q������D��M�M�M�!%��d���d�!2�D��J�J�
�2�X�X� 1�"�g�w�� N� N��G�X��*�*�
$�u��/F�
$���]�#�#�#�#��
$���R������
$���Y�������]�#�#�#��4��:�:�D�t�t�A�w�w�w��W�e�T�2�2�2���d���d�*�D��J�J�
�3�Y�Y���&�
���W�
�
�
�
���S�	�	�	�	�
�?�
"�
"��(�(�
R��e�B�B�P�Q�Q�Q��r�!�u�~�~�
-���_�R�(��+�,�,�,��t�D�z�z��4�4��7�7�7���R��U������R��U������r�!�u�e�,�,�,���W�
�
�
�!�T�$�Z�Z�$�.��T�
�
���_�R�(��+�,�,�,��t�D�z�z��4�4��7�7�7���R��U������R��U������r�!�u�e�,�,�,�!�T�$�Z�Z�$�.��T�
���_�R�(��+�,�,�,�,�
�:�
�
�-/�*�E�9�i���
"���T�
�
�
���e�A�g�q�[�!�!�!��T�1�n�U�I�y�I�I�J�J�J��
$���T�
�
�
���e�A�g�q�[��]�#�#�#��
�<�
�
�
�D������4��:�:�D�t�t�A�w�w�w��T�2�u�%�%�%��D��M�M�M���d���d�*�D��J�J�
�=�
 �
 ��D��H�H�H�H�
�<�
�
��D��H�H�H��4��:�:�D�t�t�A�w�w�w��!�u��z�z���Q������A����)�)���B���<�<�� 7�8�8�8���8�8�� J�K�K�K���R�����T�2�a�5�%�(�(�(��D��M�M�M���d���d�*�D��J�J�
�2�X�X��D��H�H�H��)�)�
.�!�%�%�b�"�-�-����&�
,��]�]�2�r�*�*����)�)�
,��^�^�B��+�+���D��H�H�H�H�
�6�\�\��D��H�H�H��D���J���e�
/�
/���t�D�z�z��4�4��7�7�7���r�5�)�)�)���T�
�
�
��
�4�4��:�:�&�&�&���Q����!�T�$�Z�Z�$�.��T�
�
��D��M�M�M��
/�
/��!�T�$�Z�Z�$�.��T�
�
�
/�
�8�^�^��D��H�H�H���&�
$��r�]����)�)�
$���^���D��H�H�H�H�
�8�^�^��.�.�
*���R�������(�
*���(�)�)�)�)��
*���_�%�%�%�%���(�)�)�)��D��A��J�J�J�J�
�?�
"�
"��D��H�H�H��D��A��q��M�M�M��d�4�j�j�G�$�$�q�'�'�'��T�2�a�5�%�(�(�(��!�u�
9���T�
�
�
���d����T�T�!�W�W�W� $��T�
�
�W� 4�q� 8��W�
���r�!�u�e�,�,�,�#�t�D�z�z�F�2��V��� $��T�
�
�W� 4�q� 8��W�
�
��%�2�2�G�H�H�H�}^I�^Irc�P�|j}|D�]
\}}||��|tur�|tur||���0|tus	|tur#||d��||d���e|t
ur|�|����|tur|�|����|turN|tzr|t|����|tzr|t|����||����td|�����|t��dS)Nrrz#internal: unsupported set operator )rr&r'�RANGE�RANGE_UNI_IGNORE�CHARSET�extend�
BIGCHARSETrCrrDrrEr2r()r[r
rKrMrVrWs      rr-r-�sD���;�D��I�I���B���R����
��<�<��
�7�]�]��D��H�H�H�H�
�5�[�[�B�"2�2�2��D��A��K�K�K��D��A��K�K�K�K�
�7�]�]��K�K��O�O�O�O�
�:�
�
��K�K��O�O�O�O�
�8�^�^���&�
���Y�r�]�#�#�#�#��)�)�
���Z��^�$�$�$�$���R������%�2�2�G�H�H�H��D��M�M�M�M�Mrc�l�g}g}td��}d}|D�]}\}}			|tur>|r6||	��}
d||
<|r|
|vr||
D]}d||<�|s
||	��rd}n�d||	<n�|tur�t|	d|	ddz��}|rg|r-t	||��D]}
d||
<|
|vr||
D]}d||<��nt	||��D]}
d||
<�|stt	||����}nC|D]}
d||
<�n8|tur|�||	f��n|�||	f��nY#t$rLt|��dkr|ddzz
}Y��F|rd}|turt}|�||	f��YnwxYw��g}d}	|�d|��}|dkrnot|��dkrd}nY|�d|��}|dkr%|�|t|��f��n|�||f����|�~|D]L\}}||z
dkr|�t|f���+|�t||dz
ff���M||z
}|s t|��t|��kr||fS||fSt|��dkr4t|��}|�t|f��||z
}||fSt|��}i}td��}d}t��}tdd	d��D]9}
||
|
dz�}||vr||||
dz<�"|x||
dz<||<|dz
}||z
}�:t|��}|gt|��z|dd�<|�t |f��||z
}||fS)
N�FTrr�i�ri)�	bytearrayr're�range�map�anyr&r�
IndexErrorrrf�find�
_mk_bitmaprg�bytes�_bytes_to_codesri)r[rS�fixuprU�outr`�charmapr\rVrWrXrZ�r�i�runs�qr^�data�comps�mapping�block�chunks                      rr*r*�s���
�C�
�D���n�n�G��H��9�9���B�8	�6
&���=�=��	(�"�U�2�Y�Y��&'���� �/�R�5�[�[�%*�2�Y�/�/��-.���
�
�'�,�G�G�B�K�K�,�'+�H��&'������5�[�[��b��e�R��U�1�W�-�-�A��+� �/�%(���]�]�7�7��-.���
�#$��:�:�-2�1�X�%7�%7��56���
�
��	7�&)���]�]�/�/��-.���
�
�'�<�'*�3�w��?�?�';�';�H��!"�+�+�A�)*�G�A�J�J�+��6�\�\��J�J��B�x�(�(�(�(��K�K��R��)�)�)����
&�
&�
&��w�<�<�3�&�&��u�v�~�-�G��H��.�#�H��U�{�{�-�����R��H�%�%�%�%�%�+
&����,
��D�	�A���L�L��A�����q�5�5���t�9�9��>�>��D���L�L��A�����q�5�5��K�K��C��L�L�)�*�*�*�����Q��F��������	0�	0�D�A�q��1�u��z�z��
�
�G�Q�<�(�(�(�(��
�
�E�A�q�1�u�:�.�/�/�/�/��t����	!�s�3�x�x�#�g�,�,�.�.���=� ��� � ��7�|�|�s����'�"�"���
�
�G�T�?�#�#�#��t����H�}��,�G�n�n�G��E���n�n�G�
�E��;�;�D�
�1�e�S�
!�
!������1�s�7�
�#���E�>�>� %�e��G�A��H���/4�4�G�A��H���e���Q�J�E��E�M�D�D��d���D���/�'�2�2�2�D��1��I��J�J�
�D�!�"�"�"��4�K�C���=�s�DD<�<%F�$+F�F�s0111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111c�����|�t��ddd�����fd�tt���d���D��S)N���c�>��g|]}��|�z
|�d����S)rr	)�.0rz�	_CODEBITS�_int�ss  ���r�
<listcomp>z_mk_bitmap.<locals>.<listcomp>�sC���3�3�3��
�D��1�y�=�!�#�$�a�(�(�3�3�3rr)�	translate�_BITS_TRANSrnr)�bitsr�r�r�s ``@rrsrs�sj��������{�#�#�D�D�b�D�)�A�3�3�3�3�3�3��3�q�6�6�1�y�j�1�1�3�3�3�3rc�n�t|���d��}|���S)N�I)�
memoryview�cast�tolist)�b�as  rruru�s+���1�
�
���3���A�
�8�8�:�:�rc��t|��dkrdS|d\}}|tur|dduot|d��S|tvS)NrFrr�)rr6r3�_UNIT_CODES)r^rVrWs   rr3r3�sV��
�1�v�v��{�{��u�
�q�T�F�B��	�Z����!�u��}�0���B����0�
���rc��dgt|��z}tdt|����D]P}||dz
}||||kr)|dkrd||<n%||dz
}||||k�)|dz||<�Q|S)aj
    Generate an overlap table for the following prefix.
    An overlap table is a table of the same size as the prefix which
    informs about the potential self-overlap for each index in the prefix:
    - if overlap[i] == 0, prefix[i:] can't overlap prefix[0:...]
    - if overlap[i] == k with 0 < k <= i, prefix[i-k+1:i+1] overlaps with
      prefix[0:k]
    rr)rrn)�prefix�tablerz�idxs    r�_generate_overlap_tabler��s����C�#�f�+�+��E�
�1�c�&�k�k�
"�
"�����A��E�l���Q�i�6�#�;�&�&��a�x�x���a�����a��.�C�	�Q�i�6�#�;�&�&��Q�w�E�!�H���Lrc�^�|tzsdS|tzrtjStjSr)rrrrr)r
s r�_get_iscasedr��s5���&�&�"��t�	�!�	!�"��#�#��!�!rc���g}|j}d}t|��}|jD]�\}}|tur|r
||��rn�||���)|tur�|\}}	}
}t||	|
��}|tzr|tzrn]t||��\}
}}|�&|�t|��}n|�t|��|z}|�
|
��|sn��n||dfS||dfS)NTF)rr�r}r'r6rrr�_get_literal_prefixrrh)rLr
r��prefixappend�prefix_skiprSrVrWr]rrr^�flags1�prefix1�prefix_skip1�got_alls                rr�r��s@��
�F��=�L��K��5�!�!�G��,�)�)���B�
��=�=��
�7�7�2�;�;�
����L������
�:�
�
�-/�*�E�9�i��#�E�9�i�@�@�F��+�+�
���0H�
���-@��F�-K�-K�*�G�\�7��"��$�"%�f�+�+�K�K�!�-�"%�f�+�+��"<�K��M�M�'�"�"�"��
���
�
�E��{�D�(�(��;��%�%rc��	|jsdS|jd\}}|turn/|\}}}}t|||��}|tzr|tzrdS�Rt|��}|tur|r
||��rdS||fgS|turLg}|j}	|dD]8}
|
sdS|
d\}}|tur|r||��s|	||f���6dS|S|tur{|}|ru|D]r\}}|tur||��rdS�|turL|ddkrdStt|t|d|ddz������rdS�s|SdS)NTrri��)r}r6rrrr�r'rArr)rerprorn)rLr
rVrWr]rrrSr[�
charsetappendr^s           r�_get_charset_prefixr��s���	��|�	��4���a����B�
�Z����/1�,��y�)�W��u�i��;�;���&�&�	�5�?�+B�	��4�	��5�!�!�G�	�W�}�}��	�w�w�r�{�{�	��4��R��z��	�v�������
��A��	�	�A��
��t�t��q�T�F�B���W�}�}�g�}�'�'�"�+�+�}��
�r�2�h�'�'�'�'��t�t���	�r������		$�!�
$�
$���B���=�=��w�r�{�{�$�#�t�t�$��5�[�[��!�u�v�~�~�#�t�t��3�w��b��e�R��U�1�W�(=�(=�>�>�?�?�$�#�t�t�����4rc��|���\}}|tkrt}|dkr!|�tdd||g��dSg}d}g}|tzr
|t
zs&t
||��\}}}|st||��}|j}	|	t��t|��}
|	d��d}|rt}|�|r
|tz}n|r
|tz}|	|��|tkr|	|��n|	t��|dt�}|	|��|rl|	t|����|�t|��}|	|��|�|��|�t|����n%|r#t|��\}}t|||��t|��|
z
||
<dS)Nr�)r9r:rh�INFOrrr�r�rr�SRE_INFO_PREFIX�SRE_INFO_LITERAL�SRE_INFO_CHARSETr�r*r-)
rKrLr
rXr_r�r�r[r�rMrY�maskr\s
             r�
_compile_infor��s���
�
�
�
�F�B��	�G�|�|�
��	�Q�w�w����T�1�a��R�(�)�)�)���
�F��K��G��'�'�:�E�O�,C�:�':�7�E�'J�'J�$���W��	:�)�'�5�9�9�G��;�D��D��J�J�J��t�9�9�D�d�d�1�g�g�g��D�
�'�����7���*�*�D��	�'��&�&���D��J�J�J�	�G�|�|���R�������W�
�
�
�����!���D��H�H�H�
�/���S��[�[�������v�;�;�K���[�������F�������+�F�3�3�4�4�4�4�	�/�-�g�6�6������%��.�.�.��T���T�!�D��J�J�Jrc�:�t|ttf��Sr)�
isinstance�strrt)�objs r�isstringr�:s���c�C��<�(�(�(rc��|jj|z}g}t|||��t||j|��|�t��|Sr)�stater
r�r4r}rr5)r^r
rKs   r�_coder�=sV��
�G�M�E�!�E�
�D��$��5�!�!�!�
�T�1�6�5�!�!�!��K�K������Krc�F�dd�d�|D����zS)N�[%s]�, c3�DK�|]}dtjdzdz|fzV��dS)z%#0*xrN)r�CODESIZE�r��xs  r�	<genexpr>z_hex_code.<locals>.<genexpr>Ms7����M�M�1�g���q���):�A�(>�>�M�M�M�M�M�Mr)�join)rKs r�	_hex_coder�Ls(���D�I�I�M�M��M�M�M�M�M�M�Mrc���������ddl�t���d�ttt���dz
�����������fd���dt�����dS)Nrrc�����dd�����fd�
}��fd�}�dz
��}||k�rB|��|}|dz
}t|}|ttttt
ttfvr
||���n�|ttttttttfvr-�|}|dz
}||d|t!|��fz���n�|t"ur=�|}|dz
}t%t&|��}|||dd����n=|t(ur=�|}|dz
}t%t*|��}|||dd����n�|t,t.t0t2fvr2�|}|||||z����|dz||z��||z
}�n�|t4t6fvrD�||dz�\}}	|dz
}||d	||	t!|��t!|	��fz���nU|t8ur;||t;�||d
t<zz�����|d
t<zz
}�n|t>urȉ|}|dz
}tAd�!�fd��||d
tDj#zz�D������}
||||
��|d
tDj#zz
}�dz
�tI|��D]:}|t;�||d
t<zz�����|d
t<zz
}�;�dz��n@|tJtLtNtPtRfvr�|}|dz
}|||���n|tTur �|}|||||z���|dz
}�n�|tVuri�|}|||||z���|rG�|dz||z��||z
}|��|}|r|d
|||z���n|t��|�G|dz
}�nh|tXtZt\t^t`fvrJ�||dz�\}}}
|
tbkrd}
|||||
||z����|dz||z��||z
}�n�|tdur)�||dz�\}}||||||z���|dz
}�n�|tfthfvr;�||dz�\}}||||||z����|dz||z��||z
}�n|tjur2�|}|||||z����|dz||z��||z
}�nD|tlu�r+�||dz�\}}}}
|
tbkrd}
|||to|��||
||z���|dz�|tpzr��|dz|dz�\}}|d|��|dz����|z�}|ddd�!d�|D����zdd�!tst |����z���|z
�|d���|z����|z
�|ttzr$�dz
�|d����||z���dz�||z
}ntw|���||k��B�dz�dS)N)�toc���|���|��|d|fzfz
}td����vrdndfzd�dz
z���t|�dS)Nz(to %d)z%*d%s �:�.z  r��end)�add�print)r��args�labels�level�offset_width�starts  ����r�print_z!dis.<locals>.dis_.<locals>.print_Wst����~��
�
�2������b�U�*�,�,���(�l�E�%�6�/�/�3�3�s�S�S��E�!�G�n�
&�
&�
&�
&��4�L�L�L�Lrc�L��td�d�zzz���t|�dS)N� rr�)r�)r�r�r�s ��r�print_2z"dis.<locals>.dis_.<locals>.print_2_s/����c�<�!�E�'�1�2�3�3�3�3��4�L�L�L�Lrrz
%#02x (%r)��	rz%#02x %#02x (%r-%r)rkrc3�b�K�|])}|�tj�j��V��*dSr)�to_bytesrr��	byteorder)r�r��syss  �rr�z$dis.<locals>.dis_.<locals>.<genexpr>�sQ�����(R�(R�,-�)*�
�
�4�=�#�-�(P�(P�(R�(R�(R�(R�(R�(Rr�branch�	MAXREPEATr��z
  prefix_skipz  prefixr�r�c3� K�|]	}d|zV��
dS)z%#02xNr	r�s  rr�z$dis.<locals>.dis_.<locals>.<genexpr>�s&����.K�.K�q�w��{�.K�.K�.K�.K�.K�.Krz(%r)�z	  overlap�in)<�OPCODESr5r(r.r0�	MAX_UNTIL�	MIN_UNTILr&r'r%�LITERAL_IGNORE�NOT_LITERAL_IGNORE�LITERAL_UNI_IGNORE�NOT_LITERAL_UNI_IGNORE�LITERAL_LOC_IGNORE�NOT_LITERAL_LOC_IGNORE�chrr;r��ATCODESrC�CHCODESr)r,r$r+rerfrgr�r�ri�listr�rr�rnr7rFrHrIrGrBrA�REPEAT�
REPEAT_ONE�MIN_REPEAT_ONE�POSSESSIVE_REPEAT�POSSESSIVE_REPEAT_ONEr�rJ�ASSERT�
ASSERT_NOTr8r��binr�ror��
ValueError)r�r�r�r�rzrV�argrYrXr_r�j�min�maxr
�
prefix_lenr�r�rK�dis_r�r�r�r�s`                 ������rr�zdis.<locals>.dis_Vs;����!�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�
	��
�����#�g�g��E��a��B�
��F�A����B��g�w��W���F�4�4�4���r�
�
�
�
����&�(:�*�,B�*�,B�D�D�D��1�g���Q�����r�<�3��C���/�9�:�:�:�:��r����1�g���Q����'�#�,�'�'����r�3�q�r�r�7�#�#�#�#��x����1�g���Q����'�#�,�'�'����r�3�q�r�r�7�#�#�#�#���I�}�m�D�D�D��A�w����r�4�A�d�F�+�+�+�+���Q�q�S�!�D�&�!�!�!��T�	�����/�0�0�0��a��1��f����B��Q�����r�0�B��C��G�G�S��W�W�3M�M�N�N�N�N��w�����r�9�T�!�Q��i��-?�*?�%@�A�A�B�B�B��S�)�^�#����z�!�!��1�g���Q����s�x�x�(R�(R�(R�(R�15�a��S�$�-�=O�9O�6O�1P�(R�(R�(R� R� R�S�S����r�3��(�(�(��S�$�-�'�'����
���s���(�(�A��G�I�d�1�a�#�y�.�.@�+@�&A�B�B�C�C�C���i��'�A�A���
�����h��9L�+�-�-�-��1�g���Q�����r�3������t����A�w����r�4�A�d�F�+�+�+�+��Q�����v����A�w����r�4�A�d�F�+�+�+�+��(��D��1��a��f�%�%�%���I�A��E���7�D��(���x��!�D�&�9�9�9�9�9���w�����(��Q������
�N�)�+@�B�B�B�!%�a��1��f����c�3��)�#�#�%�C���r�4��c�a��f�5�5�5�5���Q�q�S�!�D�&�!�!�!��T�	�����&�&� ��A�a�C��L�	��T���r�3���4��0�0�0�0��Q������
�+�+�+� ��A�a�C��L�	��c���r�4���4��0�0�0�0���Q�q�S�!�D�&�!�!�!��T�	����|�#�#��A�w����r�4�A�d�F�+�+�+�+���Q�q�S�!�D�&�!�!�!��T�	����t���(,�Q��!��V��%��e�S�#��)�#�#�%�C���r�4��U���S�#�!�D�&�A�A�A�A��!����?�*�
(�.2�1�Q�3��!��8�n�+�J���G�O�[�9�9�9���E�E�!�%��z�)9�"9�:�F��G�J�"�T�Y�Y�.K�.K�F�.K�.K�.K�%K�%K�K�"�R�W�W�S��f�-=�-=�%>�%>�>�@�@�@��Z�'�E��G�K��e�U�:�5E�.E�)F�G�G�G��Z�'�E��+�+���Q�J�E��G�D�M�M�M��D���$��'�'�'��Q�J�E��T�	��� ��n�n�$�o�#�g�g�r	��
���r)r��setrr�)rKr�r�r�r�r�s`@@@@@r�disr�Os����������J�J�J�
�U�U�F�
�E��s�3�t�9�9�q�=�)�)�*�*�L�I�I�I�I�I�I�I�I�I�I�V	�D��C��I�I�����rc
��t|��r|}tj||��}nd}t||��}|tzrt��t
|��|jj}dg|jj	z}|�
��D]
\}}|||<�tj|||jj
z||jj	dz
|t|����S)Nr)r�r�parser��SRE_FLAG_DEBUGr�r�r��	groupdict�groups�itemsr�compiler
�tuple)r^r
rLrK�
groupindex�
indexgrouprZrzs        rrr�s�����{�{�����M�!�U�#�#�������E�?�?�D��~���
�����D�	�	�	���"�J���!�'�.�(�J�� � �"�"�����1��
�1�
�
��<������&��	���q���E�*�%�%�
�
�
r)NNN)r)4�__doc__rr�r�
_constants�_casefixrr'r%rr5r(rr�r�rr.r)r��
MIN_REPEATr�r�r��
MAX_REPEATr�r�r�r�rr
rr4r-r*r�r�r:r��intrsrur3r�r�r�r�r�r�r�r�r�rr	rr�<module>rs��&�%���������������"�"�"�"�"�"��;�'���7�#����$�
���R�y�(�����N�3����J�/��)�7�4I�J���&�0�,�,�,�,�qI�qI�qI�f���6J�J�J�J�X
�M�A��	��	�>�Q�
����(�s�3�3�3�3�
���������*"�"�"�&�&�&�>*�*�*�X9"�9"�9"�v)�)�)�
�
�
�N�N�N�R�R�R�j
�
�
�
�
�
rPKV*]�ـ�|�|%__pycache__/_compiler.cpython-311.pycnu�[����

A��k������J�dZddlZddlmZddlTddlmZejeks
Jd���ee	hZ
eehZ
eehZe
eehzZeeeefeeeefeeeefiZejfd�Zd	�Z d
�Z!dd�Z"ej#dzZ$de$zdz
Z%d
Z&e$e'fd�Z(d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d�Z1d�Z2d�Z3dd�Z4dS)zInternal support module for sre�N�)�_parser)�*)�_EXTRA_CASESzSRE module mismatchc�*�||zr||z}||z|zS�N�)�flags�	add_flags�	del_flags�
TYPE_FLAGSs    �7/opt/alt/python-internal/lib/python3.11/re/_compiler.py�_combine_flagsrs-���:���
�*�����I��)��+�+�c
��|j}t}t}t}t}t
}d}	d}
d}|tzrL|tzsB|tzr tj
}	tj}
t}ntj
}	tj}
|D�]=\}}
||v�rP|tzs||��||
���,|tzr"|t|��||
���X|	|
��s||��||
���z|
|
��}|s"|t |��||����||vr"|t"|��||����|t$��||��}|d��|t&ur|t(��|f||zD]}|t*��||���|t,��||��|z
||<��[|t.ur�t1|
|	|
|��\}}|tzr|tzr|t2��n6|s|t.��n#|s|t4��n|t$��||��}|d��t7|||��||��|z
||<��|t8ur.|t:zr|t<����3|t8����E||v�rJ|t>zrtAd|�����tC|
d��r�|||d��||��}|d��||
d��||
d��tE||
d|��|tF��||��|z
||<��|||d��||��}|d��||
d��||
d��tE||
d|��||��|z
||<|||d�����|tHurr|
\}}}}|r!|tJ��||dz
dz��tE||tM|||����|r$|tJ��||dz
dzdz����|tNurZ|tN��||��}|d��tE||
|��|tF��||��|z
||<��r||vr
||�����||vr�||��||��}|d��|
ddkr|d��nW|
d�(��\}}|tRkrtAd���||krtAd���||��tE||
d|��|tF��||��|z
||<��Q|tTur�||��|tVzrtX�-|
|
��}
|tzrt\�-|
|
��}
n%|tzrt^�-|
|
��}
||
�����|t`ur�||��g}|j}|
dD]i}
||��}|d��tE||
|��|tb��|||����|d��||��|z
||<�j|t,��|D]}||��|z
||<����|tdurG||��|tzrtf|
}
n|tzr
th|
}
||
�����|tjurd|tzs||��n>|tzr|tl��n#|s|tn��n|tp��||
dz
����V|trur�||��||
ddz
��||��}|d��tE||
d|��|
drd|tb��||��}|d��||��|z
dz||<tE||
d|��||��|z
||<��||��|z
dz||<��-tAd|�����dS)Nrz(internal: unsupported template operator �rzlooks too much behindz(look-behind requires fixed-width patternz#internal: unsupported operand type ):�append�len�_LITERAL_CODES�_REPEATING_CODES�_SUCCESS_CODES�
_ASSERT_CODES�SRE_FLAG_IGNORECASE�SRE_FLAG_LOCALE�SRE_FLAG_UNICODE�_sre�unicode_iscased�unicode_tolowerr�
ascii_iscased�
ascii_tolower�OP_LOCALE_IGNORE�	OP_IGNORE�OP_UNICODE_IGNORE�
IN_UNI_IGNORE�NOT_LITERAL�NEGATE�LITERAL�FAILURE�IN�_optimize_charset�
IN_LOC_IGNORE�	IN_IGNORE�_compile_charset�ANY�SRE_FLAG_DOTALL�ANY_ALL�SRE_FLAG_TEMPLATE�error�_simple�_compile�SUCCESS�
SUBPATTERN�MARKr�ATOMIC_GROUP�getwidth�MAXCODE�AT�SRE_FLAG_MULTILINE�AT_MULTILINE�get�	AT_LOCALE�
AT_UNICODE�BRANCH�JUMP�CATEGORY�	CH_LOCALE�
CH_UNICODE�GROUPREF�GROUPREF_LOC_IGNORE�GROUPREF_IGNORE�GROUPREF_UNI_IGNORE�GROUPREF_EXISTS)�code�patternr
�emit�_len�
LITERAL_CODES�REPEATING_CODES�
SUCCESS_CODES�ASSERT_CODES�iscased�tolower�fixes�op�av�lo�skip�k�charset�hascased�grouprr�p�hi�tail�
tailappend�skipyes�skipnos                            rr4r4%s�	���;�D��D�"�M�&�O�"�M� �L��G��G��E��"�"�)�5�?�+B�)��#�#�	)��*�G��*�G� �E�E��(�G��(�G��^I�^I���B�
�����.�.�
3���R������R�������(�
3���%�b�)�*�*�*���R������W�R�[�[�
3���R������R������W�R�[�[���3��D��2��'�'�'��D��H�H�H�H��u�_�_��D�*�2�.�/�/�/��D��H�H�H�H��D��'�'�'��4��:�:�D�t�t�A�w�w�w��[�(�(���V���� �U�U�2�Y�.� � ����W�
�
�
���Q������D��M�M�M�!%��d���d�!2�D��J�J�
�2�X�X� 1�"�g�w�� N� N��G�X��*�*�
$�u��/F�
$���]�#�#�#�#��
$���R������
$���Y�������]�#�#�#��4��:�:�D�t�t�A�w�w�w��W�e�T�2�2�2���d���d�*�D��J�J�
�3�Y�Y���&�
���W�
�
�
�
���S�	�	�	�	�
�?�
"�
"��(�(�
R��e�B�B�P�Q�Q�Q��r�!�u�~�~�
-���_�R�(��+�,�,�,��t�D�z�z��4�4��7�7�7���R��U������R��U������r�!�u�e�,�,�,���W�
�
�
�!�T�$�Z�Z�$�.��T�
�
���_�R�(��+�,�,�,��t�D�z�z��4�4��7�7�7���R��U������R��U������r�!�u�e�,�,�,�!�T�$�Z�Z�$�.��T�
���_�R�(��+�,�,�,�,�
�:�
�
�-/�*�E�9�i���
"���T�
�
�
���e�A�g�q�[�!�!�!��T�1�n�U�I�y�I�I�J�J�J��
$���T�
�
�
���e�A�g�q�[��]�#�#�#��
�<�
�
�
�D������4��:�:�D�t�t�A�w�w�w��T�2�u�%�%�%��D��M�M�M���d���d�*�D��J�J�
�=�
 �
 ��D��H�H�H�H�
�<�
�
��D��H�H�H��4��:�:�D�t�t�A�w�w�w��!�u��z�z���Q������A����)�)���B���<�<�� 7�8�8�8���8�8�� J�K�K�K���R�����T�2�a�5�%�(�(�(��D��M�M�M���d���d�*�D��J�J�
�2�X�X��D��H�H�H��)�)�
.�!�%�%�b�"�-�-����&�
,��]�]�2�r�*�*����)�)�
,��^�^�B��+�+���D��H�H�H�H�
�6�\�\��D��H�H�H��D���J���e�
/�
/���t�D�z�z��4�4��7�7�7���r�5�)�)�)���T�
�
�
��
�4�4��:�:�&�&�&���Q����!�T�$�Z�Z�$�.��T�
�
��D��M�M�M��
/�
/��!�T�$�Z�Z�$�.��T�
�
�
/�
�8�^�^��D��H�H�H���&�
$��r�]����)�)�
$���^���D��H�H�H�H�
�8�^�^��.�.�
*���R�������(�
*���(�)�)�)�)��
*���_�%�%�%�%���(�)�)�)��D��A��J�J�J�J�
�?�
"�
"��D��H�H�H��D��A��q��M�M�M��d�4�j�j�G�$�$�q�'�'�'��T�2�a�5�%�(�(�(��!�u�
9���T�
�
�
���d����T�T�!�W�W�W� $��T�
�
�W� 4�q� 8��W�
���r�!�u�e�,�,�,�#�t�D�z�z�F�2��V��� $��T�
�
�W� 4�q� 8��W�
�
��%�2�2�G�H�H�H�}^I�^Irc�P�|j}|D�]
\}}||��|tur�|tur||���0|tus	|tur#||d��||d���e|t
ur|�|����|tur|�|����|turN|tzr|t|����|tzr|t|����||����td|�����|t��dS)Nrrz#internal: unsupported set operator )rr&r'�RANGE�RANGE_UNI_IGNORE�CHARSET�extend�
BIGCHARSETrCrrDrrEr2r()r[r
rKrMrVrWs      rr-r-�sD���;�D��I�I���B���R����
��<�<��
�7�]�]��D��H�H�H�H�
�5�[�[�B�"2�2�2��D��A��K�K�K��D��A��K�K�K�K�
�7�]�]��K�K��O�O�O�O�
�:�
�
��K�K��O�O�O�O�
�8�^�^���&�
���Y�r�]�#�#�#�#��)�)�
���Z��^�$�$�$�$���R������%�2�2�G�H�H�H��D��M�M�M�M�Mrc�l�g}g}td��}d}|D�]}\}}			|tur>|r6||	��}
d||
<|r|
|vr||
D]}d||<�|s
||	��rd}n�d||	<n�|tur�t|	d|	ddz��}|rg|r-t	||��D]}
d||
<|
|vr||
D]}d||<��nt	||��D]}
d||
<�|stt	||����}nC|D]}
d||
<�n8|tur|�||	f��n|�||	f��nY#t$rLt|��dkr|ddzz
}Y��F|rd}|turt}|�||	f��YnwxYw��g}d}	|�d|��}|dkrnot|��dkrd}nY|�d|��}|dkr%|�|t|��f��n|�||f����|�~|D]L\}}||z
dkr|�t|f���+|�t||dz
ff���M||z
}|s t|��t|��kr||fS||fSt|��dkr4t|��}|�t|f��||z
}||fSt|��}i}td��}d}t��}tdd	d��D]9}
||
|
dz�}||vr||||
dz<�"|x||
dz<||<|dz
}||z
}�:t|��}|gt|��z|dd�<|�t |f��||z
}||fS)
N�FTrr�i�ri)�	bytearrayr're�range�map�anyr&r�
IndexErrorrrf�find�
_mk_bitmaprg�bytes�_bytes_to_codesri)r[rS�fixuprU�outr`�charmapr\rVrWrXrZ�r�i�runs�qr^�data�comps�mapping�block�chunks                      rr*r*�s���
�C�
�D���n�n�G��H��9�9���B�8	�6
&���=�=��	(�"�U�2�Y�Y��&'���� �/�R�5�[�[�%*�2�Y�/�/��-.���
�
�'�,�G�G�B�K�K�,�'+�H��&'������5�[�[��b��e�R��U�1�W�-�-�A��+� �/�%(���]�]�7�7��-.���
�#$��:�:�-2�1�X�%7�%7��56���
�
��	7�&)���]�]�/�/��-.���
�
�'�<�'*�3�w��?�?�';�';�H��!"�+�+�A�)*�G�A�J�J�+��6�\�\��J�J��B�x�(�(�(�(��K�K��R��)�)�)����
&�
&�
&��w�<�<�3�&�&��u�v�~�-�G��H��.�#�H��U�{�{�-�����R��H�%�%�%�%�%�+
&����,
��D�	�A���L�L��A�����q�5�5���t�9�9��>�>��D���L�L��A�����q�5�5��K�K��C��L�L�)�*�*�*�����Q��F��������	0�	0�D�A�q��1�u��z�z��
�
�G�Q�<�(�(�(�(��
�
�E�A�q�1�u�:�.�/�/�/�/��t����	!�s�3�x�x�#�g�,�,�.�.���=� ��� � ��7�|�|�s����'�"�"���
�
�G�T�?�#�#�#��t����H�}��,�G�n�n�G��E���n�n�G�
�E��;�;�D�
�1�e�S�
!�
!������1�s�7�
�#���E�>�>� %�e��G�A��H���/4�4�G�A��H���e���Q�J�E��E�M�D�D��d���D���/�'�2�2�2�D��1��I��J�J�
�D�!�"�"�"��4�K�C���=�s�DD<�<%F�$+F�F�s0111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111c�����|�t��ddd�����fd�tt���d���D��S)N���c�>��g|]}��|�z
|�d����S)rr	)�.0rz�	_CODEBITS�_int�ss  ���r�
<listcomp>z_mk_bitmap.<locals>.<listcomp>�sC���3�3�3��
�D��1�y�=�!�#�$�a�(�(�3�3�3rr)�	translate�_BITS_TRANSrnr)�bitsr�r�r�s ``@rrsrs�sj��������{�#�#�D�D�b�D�)�A�3�3�3�3�3�3��3�q�6�6�1�y�j�1�1�3�3�3�3rc���t|���d��}|jtjksJ�t|��|jzt|��ksJ�|���S)N�I)�
memoryview�cast�itemsizer�CODESIZEr�tolist)�b�as  rruru�sb���1�
�
���3���A��:���&�&�&�&��q�6�6�A�J��#�a�&�&�(�(�(�(��8�8�:�:�rc��t|��dkrdS|d\}}|tur|dduot|d��S|tvS)NrFrr�)rr6r3�_UNIT_CODES)r^rVrWs   rr3r3�sV��
�1�v�v��{�{��u�
�q�T�F�B��	�Z����!�u��}�0���B����0�
���rc��dgt|��z}tdt|����D]P}||dz
}||||kr)|dkrd||<n%||dz
}||||k�)|dz||<�Q|S)aj
    Generate an overlap table for the following prefix.
    An overlap table is a table of the same size as the prefix which
    informs about the potential self-overlap for each index in the prefix:
    - if overlap[i] == 0, prefix[i:] can't overlap prefix[0:...]
    - if overlap[i] == k with 0 < k <= i, prefix[i-k+1:i+1] overlaps with
      prefix[0:k]
    rr)rrn)�prefix�tablerz�idxs    r�_generate_overlap_tabler��s����C�#�f�+�+��E�
�1�c�&�k�k�
"�
"�����A��E�l���Q�i�6�#�;�&�&��a�x�x���a�����a��.�C�	�Q�i�6�#�;�&�&��Q�w�E�!�H���Lrc�^�|tzsdS|tzrtjStjSr)rrrrr)r
s r�_get_iscasedr��s5���&�&�"��t�	�!�	!�"��#�#��!�!rc���g}|j}d}t|��}|jD]�\}}|tur|r
||��rn�||���)|tur�|\}}	}
}t||	|
��}|tzr|tzrn]t||��\}
}}|�&|�t|��}n|�t|��|z}|�
|
��|sn��n||dfS||dfS)NTF)rr�r}r'r6rrr�_get_literal_prefixrrh)rLr
r��prefixappend�prefix_skiprSrVrWr]rrr^�flags1�prefix1�prefix_skip1�got_alls                rr�r��s@��
�F��=�L��K��5�!�!�G��,�)�)���B�
��=�=��
�7�7�2�;�;�
����L������
�:�
�
�-/�*�E�9�i��#�E�9�i�@�@�F��+�+�
���0H�
���-@��F�-K�-K�*�G�\�7��"��$�"%�f�+�+�K�K�!�-�"%�f�+�+��"<�K��M�M�'�"�"�"��
���
�
�E��{�D�(�(��;��%�%rc��	|jsdS|jd\}}|turn/|\}}}}t|||��}|tzr|tzrdS�Rt|��}|tur|r
||��rdS||fgS|turLg}|j}	|dD]8}
|
sdS|
d\}}|tur|r||��s|	||f���6dS|S|tur{|}|ru|D]r\}}|tur||��rdS�|turL|ddkrdStt|t|d|ddz������rdS�s|SdS)NTrri��)r}r6rrrr�r'rArr)rerprorn)rLr
rVrWr]rrrSr[�
charsetappendr^s           r�_get_charset_prefixr��s���	��|�	��4���a����B�
�Z����/1�,��y�)�W��u�i��;�;���&�&�	�5�?�+B�	��4�	��5�!�!�G�	�W�}�}��	�w�w�r�{�{�	��4��R��z��	�v�������
��A��	�	�A��
��t�t��q�T�F�B���W�}�}�g�}�'�'�"�+�+�}��
�r�2�h�'�'�'�'��t�t���	�r������		$�!�
$�
$���B���=�=��w�r�{�{�$�#�t�t�$��5�[�[��!�u�v�~�~�#�t�t��3�w��b��e�R��U�1�W�(=�(=�>�>�?�?�$�#�t�t�����4rc���|���\}}|tkrt}|dkr!|�tdd||g��dSg}d}g}|tzr
|t
zs&t
||��\}}}|st||��}|j}	|	t��t|��}
|	d��d}|rt}|�|r
|tz}n|r
|tz}|	|��|tkr|	|��n|	t��|dt�}|	|��|rl|	t|����|�t|��}|	|��|�|��|�t|����n)|r't|��\}}|rJ�t|||��t|��|
z
||
<dS)Nr�)r9r:rh�INFOrrr�r�rr�SRE_INFO_PREFIX�SRE_INFO_LITERAL�SRE_INFO_CHARSETr�r*r-)
rKrLr
rXr_r�r�r[r�rMrY�maskr\s
             r�
_compile_infor��s���
�
�
�
�F�B��	�G�|�|�
��	�Q�w�w����T�1�a��R�(�)�)�)���
�F��K��G��'�'�:�E�O�,C�:�':�7�E�'J�'J�$���W��	:�)�'�5�9�9�G��;�D��D��J�J�J��t�9�9�D�d�d�1�g�g�g��D�
�'�����7���*�*�D��	�'��&�&���D��J�J�J�	�G�|�|���R�������W�
�
�
�����!���D��H�H�H�
�/���S��[�[�������v�;�;�K���[�������F�������+�F�3�3�4�4�4�4�	�/�-�g�6�6�������|���%��.�.�.��T���T�!�D��J�J�Jrc�:�t|ttf��Sr)�
isinstance�strrt)�objs r�isstringr�:s���c�C��<�(�(�(rc��|jj|z}g}t|||��t||j|��|�t��|Sr)�stater
r�r4r}rr5)r^r
rKs   r�_coder�=sV��
�G�M�E�!�E�
�D��$��5�!�!�!�
�T�1�6�5�!�!�!��K�K������Krc�F�dd�d�|D����zS)N�[%s]�, c3�DK�|]}dtjdzdz|fzV��dS)z%#0*xrN)rr��r��xs  r�	<genexpr>z_hex_code.<locals>.<genexpr>Ms7����M�M�1�g���q���):�A�(>�>�M�M�M�M�M�Mr)�join)rKs r�	_hex_coder�Ls(���D�I�I�M�M��M�M�M�M�M�M�Mrc���������ddl�t���d�ttt���dz
�����������fd���dt�����dS)Nrrc�
���dd�����fd�
}��fd�}�dz
��}||k�rb|��|}|dz
}t|}|ttttt
ttfvr
||���n|ttttttttfvr-�|}|dz
}||d|t!|��fz���n�|t"urM�|}|dz
}t%t&|��}|dd�dksJ�|||dd����nM|t(urM�|}|dz
}t%t*|��}|dd�d	ksJ�|||dd����n�|t,t.t0t2fvr2�|}|||||z����|dz||z��||z
}�n�|t4t6fvrD�||d
z�\}}	|d
z
}||d||	t!|��t!|	��fz���nU|t8ur;||t;�||dt<zz�����|dt<zz
}�n|t>urȉ|}|dz
}tAd
�!�fd��||dtDj#zz�D������}
||||
��|dtDj#zz
}�dz
�tI|��D]:}|t;�||dt<zz�����|dt<zz
}�;�dz��n@|tJtLtNtPtRfvr�|}|dz
}|||���n|tTur �|}|||||z���|dz
}�n�|tVuri�|}|||||z���|rG�|dz||z��||z
}|��|}|r|d|||z���n|t��|�G|dz
}�nh|tXtZt\t^t`fvrJ�||dz�\}}}
|
tbkrd}
|||||
||z����|dz||z��||z
}�n�|tdur)�||d
z�\}}||||||z���|d
z
}�n�|tfthfvr;�||d
z�\}}||||||z����|d
z||z��||z
}�n|tjur2�|}|||||z����|dz||z��||z
}�nD|tlu�r+�||dz�\}}}}
|
tbkrd}
|||to|��||
||z���|dz�|tpzr��|dz|dz�\}}|d|��|dz����|z�}|ddd�!d�|D����zdd�!tst |����z���|z
�|d���|z����|z
�|ttzr$�dz
�|d����||z���dz�||z
}ntw|���||k��b�dz�dS)N)�toc���|���|��|d|fzfz
}td����vrdndfzd�dz
z���t|�dS)Nz(to %d)z%*d%s �:�.z  r��end)�add�print)r��args�labels�level�offset_width�starts  ����r�print_z!dis.<locals>.dis_.<locals>.print_Wst����~��
�
�2������b�U�*�,�,���(�l�E�%�6�/�/�3�3�s�S�S��E�!�G�n�
&�
&�
&�
&��4�L�L�L�Lrc�L��td�d�zzz���t|�dS)N� rr�)r�)r�r�r�s ��r�print_2z"dis.<locals>.dis_.<locals>.print_2_s/����c�<�!�E�'�1�2�3�3�3�3��4�L�L�L�Lrrz
%#02x (%r)��AT_�	�	CATEGORY_rz%#02x %#02x (%r-%r)rkrc3�b�K�|])}|�tj�j��V��*dSr)�to_bytesrr��	byteorder)r�r��syss  �rr�z$dis.<locals>.dis_.<locals>.<genexpr>�sQ�����(R�(R�,-�)*�
�
�4�=�#�-�(P�(P�(R�(R�(R�(R�(R�(Rr�branch�	MAXREPEATr��z
  prefix_skipz  prefixr�r�c3� K�|]	}d|zV��
dS)z%#02xNr	r�s  rr�z$dis.<locals>.dis_.<locals>.<genexpr>�s&����.K�.K�q�w��{�.K�.K�.K�.K�.K�.Krz(%r)�z	  overlap�in)<�OPCODESr5r(r.r0�	MAX_UNTIL�	MIN_UNTILr&r'r%�LITERAL_IGNORE�NOT_LITERAL_IGNORE�LITERAL_UNI_IGNORE�NOT_LITERAL_UNI_IGNORE�LITERAL_LOC_IGNORE�NOT_LITERAL_LOC_IGNORE�chrr;r��ATCODESrC�CHCODESr)r,r$r+rerfrgr�r�ri�listr�rr�rnr7rFrHrIrGrBrA�REPEAT�
REPEAT_ONE�MIN_REPEAT_ONE�POSSESSIVE_REPEAT�POSSESSIVE_REPEAT_ONEr�rJ�ASSERT�
ASSERT_NOTr8r��binr�ror��
ValueError)r�r�r�r�rzrV�argrYrXr_r�j�min�maxr
�
prefix_lenr�r�rK�dis_r�r�r�r�s`                 ������rrzdis.<locals>.dis_Vsm����!�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�
	��
�����#�g�g��E��a��B�
��F�A����B��g�w��W���F�4�4�4���r�
�
�
�
����&�(:�*�,B�*�,B�D�D�D��1�g���Q�����r�<�3��C���/�9�:�:�:�:��r����1�g���Q����'�#�,�'�'���2�A�2�w�%�'�'�'�'���r�3�q�r�r�7�#�#�#�#��x����1�g���Q����'�#�,�'�'���2�A�2�w�+�-�-�-�-���r�3�q�r�r�7�#�#�#�#���I�}�m�D�D�D��A�w����r�4�A�d�F�+�+�+�+���Q�q�S�!�D�&�!�!�!��T�	�����/�0�0�0��a��1��f����B��Q�����r�0�B��C��G�G�S��W�W�3M�M�N�N�N�N��w�����r�9�T�!�Q��i��-?�*?�%@�A�A�B�B�B��S�)�^�#����z�!�!��1�g���Q����s�x�x�(R�(R�(R�(R�15�a��S�$�-�=O�9O�6O�1P�(R�(R�(R� R� R�S�S����r�3��(�(�(��S�$�-�'�'����
���s���(�(�A��G�I�d�1�a�#�y�.�.@�+@�&A�B�B�C�C�C���i��'�A�A���
�����h��9L�+�-�-�-��1�g���Q�����r�3������t����A�w����r�4�A�d�F�+�+�+�+��Q�����v����A�w����r�4�A�d�F�+�+�+�+��(��D��1��a��f�%�%�%���I�A��E���7�D��(���x��!�D�&�9�9�9�9�9���w�����(��Q������
�N�)�+@�B�B�B�!%�a��1��f����c�3��)�#�#�%�C���r�4��c�a��f�5�5�5�5���Q�q�S�!�D�&�!�!�!��T�	�����&�&� ��A�a�C��L�	��T���r�3���4��0�0�0�0��Q������
�+�+�+� ��A�a�C��L�	��c���r�4���4��0�0�0�0���Q�q�S�!�D�&�!�!�!��T�	����|�#�#��A�w����r�4�A�d�F�+�+�+�+���Q�q�S�!�D�&�!�!�!��T�	����t���(,�Q��!��V��%��e�S�#��)�#�#�%�C���r�4��U���S�#�!�D�&�A�A�A�A��!����?�*�
(�.2�1�Q�3��!��8�n�+�J���G�O�[�9�9�9���E�E�!�%��z�)9�"9�:�F��G�J�"�T�Y�Y�.K�.K�F�.K�.K�.K�%K�%K�K�"�R�W�W�S��f�-=�-=�%>�%>�>�@�@�@��Z�'�E��G�K��e�U�:�5E�.E�)F�G�G�G��Z�'�E��+�+���Q�J�E��G�D�M�M�M��D���$��'�'�'��Q�J�E��T�	��� ��n�n�$�o�#�g�g�r	��
���r)r��setrr�)rKrr�r�r�r�s`@@@@@r�disrOs����������J�J�J�
�U�U�F�
�E��s�3�t�9�9�q�=�)�)�*�*�L�I�I�I�I�I�I�I�I�I�I�V	�D��C��I�I�����rc
��t|��r|}tj||��}nd}t||��}|tzrt��t
|��|jj}dg|jj	z}|�
��D]
\}}|||<�tj|||jj
z||jj	dz
|t|����S)Nr)r�r�parser��SRE_FLAG_DEBUGr�rr��	groupdict�groups�itemsr�compiler
�tuple)r^r
rLrK�
groupindex�
indexgrouprZrzs        rr	r	�s�����{�{�����M�!�U�#�#�������E�?�?�D��~���
�����D�	�	�	���"�J���!�'�.�(�J�� � �"�"�����1��
�1�
�
��<������&��	���q���E�*�%�%�
�
�
r)NNN)r)5�__doc__rr�r�
_constants�_casefixr�MAGICr'r%rr5r(rr�r�rr.r)r��
MIN_REPEATr�r�r��
MAX_REPEATr�r�r�r�rr
rr4r-r*r�r�r:r��intrsrur3r�r�r�r�r�r�r�r�rr	r	rr�<module>rs��&�%���������������"�"�"�"�"�"��z�U����1�����;�'���7�#����$�
���R�y�(�����N�3����J�/��)�7�4I�J���&�0�,�,�,�,�qI�qI�qI�f���6J�J�J�J�X
�M�A��	��	�>�Q�
����(�s�3�3�3�3�
���������*"�"�"�&�&�&�>*�*�*�X9"�9"�9"�v)�)�)�
�
�
�N�N�N�R�R�R�j
�
�
�
�
�
rPKV*]�\��,+,+*__pycache__/__init__.cpython-311.opt-2.pycnu�[����

��0cL�s��T�	ddlZddlmZmZddlZgd�ZdZejejej	ej
���Gd�d������ZejZd d	�Z
d d
�Zd d�Zd!d�Zd!d
�Zd!d�Zd d�Zd d�Zd d�Zd�Zd d�Zd�dD��Zd�Zeejdd����Zeejdd���
d����ZiZdZd�Zej e��d���Z!d�Z"d�Z#ddl$Z$d�Z%e$j&ee%e��Gd�d��Z'dS)"�N�)�	_compiler�_parser)�match�	fullmatch�search�sub�subn�split�findall�finditer�compile�purge�template�escape�error�Pattern�Match�A�I�L�M�S�X�U�ASCII�
IGNORECASE�LOCALE�	MULTILINE�DOTALL�VERBOSE�UNICODE�NOFLAG�	RegexFlagz2.2.1)�boundaryc���eZdZdZejxZZejxZ	Z
ejxZZ
ejxZZejxZZejxZZejxZZejxZZejZej Z e!Z"dS)r$rN)#�__name__�
__module__�__qualname__r#r�SRE_FLAG_ASCIIrr�SRE_FLAG_IGNORECASErr�SRE_FLAG_LOCALErr�SRE_FLAG_UNICODEr"r�SRE_FLAG_MULTILINErr�SRE_FLAG_DOTALLr r�SRE_FLAG_VERBOSEr!r�SRE_FLAG_TEMPLATE�TEMPLATE�T�SRE_FLAG_DEBUG�DEBUG�object�__str__�hex�_numeric_repr_���6/opt/alt/python-internal/lib/python3.11/re/__init__.pyr$r$�s��������F��(�(�E�A��2�2�J���*�*�F�Q��,�,�G�a��0�0�I���*�*�F�Q��,�,�G�a��.�.�H�q��$�E��n�G��N�N�Nr;r$c�J�	t||���|��S�N)�_compiler��pattern�string�flagss   r<rr�s%��6��G�U�#�#�)�)�&�1�1�1r;c�J�	t||���|��Sr>)r?rr@s   r<rr�s%��6��G�U�#�#�-�-�f�5�5�5r;c�J�	t||���|��Sr>)r?rr@s   r<rr�s%��6��G�U�#�#�*�*�6�2�2�2r;c�N�	t||���|||��Sr>)r?r	�rA�replrB�countrCs     r<r	r	�s+��(��G�U�#�#�'�'��f�e�<�<�<r;c�N�	t||���|||��Sr>)r?r
rGs     r<r
r
�s+��/��G�U�#�#�(�(��v�u�=�=�=r;c�L�	t||���||��Sr>)r?r)rArB�maxsplitrCs    r<rr�s)����G�U�#�#�)�)�&�(�;�;�;r;c�J�	t||���|��Sr>)r?rr@s   r<rr�s'��1��G�U�#�#�+�+�F�3�3�3r;c�J�	t||���|��Sr>)r?r
r@s   r<r
r
�s'��1��G�U�#�#�,�,�V�4�4�4r;c�$�	t||��Sr>)r?)rArCs  r<rr�s��G��G�U�#�#�#r;c�l�	t���t���dSr>)�_cache�clear�
_compile_repl�cache_clearr:r;r<rr�s*��)�
�L�L�N�N�N��������r;c��	ddl}|�dt��|���5|�dt��t||tz��cddd��S#1swxYwYdS)Nrz�The re.template() function is deprecated as it is an undocumented function without an obvious purpose. Use re.compile() instead.�ignore)�warnings�warn�DeprecationWarning�catch_warnings�simplefilterr?r3)rArCrWs   r<rr�s���H��O�O�O��M�M�.�%�	&�&�&�

�	 �	 �	"�	"�*�*����h�(:�;�;�;����q��)�)�*�*�*�*�*�*�*�*�*�*�*�*����*�*�*�*�*�*s�3A5�5A9�<A9c�4�i|]}|dt|��z��S)�\)�chr)�.0�is  r<�
<dictcomp>ra�s$��R�R�R�1�a���A����R�R�Rr;s()[]{}?*+-|^$\.&~# 	

c���	t|t��r|�t��St|d��}|�t���d��S)N�latin1)�
isinstance�str�	translate�_special_chars_map�encode)rAs r<rr�sc����'�3���F�� � �!3�4�4�4��g�x�(�(��� � �!3�4�4�;�;�H�E�E�Er;�ic��t|t��r|j}	tt	|��||fS#t
$rYnwxYwt|t��r|rtd���|Stj	|��std���|tzrddl}|�
dt��tj||��}|t zs}t#t��t$krF	tt't)t����=n#t*t,t
f$rYnwxYw|tt	|��||f<|S)Nz5cannot process flags argument with a compiled patternz1first argument must be string or compiled patternrzoThe re.TEMPLATE/re.T flag is deprecated as it is an undocumented flag without an obvious purpose. Don't use it.)rdr$�valuerQ�type�KeyErrorr�
ValueErrorr�isstring�	TypeErrorr3rWrXrYrr5�len�	_MAXCACHE�next�iter�
StopIteration�RuntimeError)rArCrW�ps    r<r?r?sz���%��#�#�����
��d�7�m�m�W�e�3�4�4���
�
�
���
�����'�7�#�#���	I��G�I�I�
I�����g�&�&�M��K�L�L�L��q�y�&������
�
�"�%�		&�	&�	&�
	��'�5�)�)�A��E�M�2��v�;�;�)�#�#�
��4��V���-�-�.�.��!�<��:�
�
�
���
����01��t�G�}�}�g�u�,�-��Hs!�;�
A�A�<'D$�$D>�=D>c�,�tj||��Sr>)r�parse_template)rHrAs  r<rSrS1s���!�$��0�0�0r;c�V�tj||��}tj||��Sr>)rry�expand_template)rArrs   r<�_expandr|6s'���%�h��8�8�H��"�8�U�3�3�3r;c��t||��}|ds't|d��dkr|ddS|fd�}|S)Nrrc�,�tj||��Sr>)rr{)rrs  r<�filterz_subx.<locals>.filterAs���&�x��7�7�7r;)rSrq)rArrs   r<�_subxr�;s]���X�w�/�/�H��A�;��3�x��{�+�+�q�0�0���{�1�~��'�8�8�8�8��Mr;c�,�t|j|jffSr>)r?rArC)rws r<�_pickler�Is���a�i���)�)�)r;c��eZdZdd�Zd�ZdS)�Scannerrc���ddlm}m}t|t��r|j}||_g}tj��}||_	|D]w\}}|�
��}	|�tj|||	ddtj
||��ffg����|�|	|d���xtj||d|ffg��}tj|��|_dS)Nr)�BRANCH�
SUBPATTERNr���)�
_constantsr�r�rdr$rk�lexiconr�StaterC�	opengroup�append�
SubPattern�parse�
closegrouprr�scanner)
�selfr�rCr�r�rw�s�phrase�action�gids
          r<�__init__zScanner.__init__Rs��2�2�2�2�2�2�2�2��e�Y�'�'�	 ��K�E�������M�O�O�����%�	%�	%�N�F�F��+�+�-�-�C�
�H�H�W�'���c�1�a���v�u�)E�)E�F�G�,���
�
�
�
�L�L��a��e�$�$�$�$���q�F�T�1�I�#6�"7�8�8�� �(��+�+����r;c�~�g}|j}|j�|��j}d}	|��}|snz|���}||krn_|j|jdz
d}t
|��r%||_|||�����}|�||��|}��|||d�fS)NrTr)r�r�r�endr��	lastindex�callable�group)	r�rB�resultr�rr`�m�jr�s	         r<�scanzScanner.scancs����������$�$�V�,�,�2��
��
	�����A��
�������A��A�v�v���\�!�+�a�-�0��3�F�����
1���
����a�g�g�i�i�0�0���!���v�����A�
	��v�a�b�b�z�!�!r;N�r)r'r(r)r�r�r:r;r<r�r�Qs7������,�,�,�,�""�"�"�"�"r;r�r�)rr)(�enumrirr�	functools�__all__�__version__�global_enum�_simple_enum�IntFlag�KEEPr$rrrrr	r
rrr
rrrrgrrlrrrQrrr?�	lru_cacherSr|r��copyregr��pickler�r:r;r<�<module>r�s���"i�V���� � � � � � � � ����������������4�<�$�)�4�4�4�
�
�
�
�
�
�
�5�4���
� 	���
2�2�2�2�
6�6�6�6�
3�3�3�3�
=�=�=�=�	>�	>�	>�	>�<�<�<�<�4�4�4�4�5�5�5�5�$�$�$�$� � � �

*�
*�
*�
*�"S�R�0Q�R�R�R��F�F�F��$� �y� ��Q�'�'�
(�
(����
�Y�
�r�1�
%�
%�
+�
+�B�
/�
/�0�0��

���	�
�
�
�B���Y���1�1� ��1�4�4�4�
�������*�*�*����w���*�*�*�
%"�%"�%"�%"�%"�%"�%"�%"�%"�%"r;PKV*]���~JJ$__pycache__/_casefix.cpython-311.pycnu�[����

]�)�����>�idd�dd�dd�dd�dd	�d
d�dd
�dd�dd�dd�dd�dd�dd�dd�dd�dd�d d!�id"d#�d$d%�d&d'�d(d)�d*d+�d,d-�d.d/�d0d1�d2d3�d4d5�d6d7�d8d9�d:d;�d<d=�d>d?�d@dA�dBdC��idDdE�dFdG�dHdI�dJdK�dLdM�dNdO�dPdQ�dRdS�dTdU�dVdW�dXdY�dZd[�d\d]�d^d_�d`da�dbdc��ZddS)e�i)�1�s)��)�r)rr)r�E)���)���)���)���)��)��r	)rr
�)��r)r�)���)����)��r)r��)��r)rr)rr)rr)rr)rr)rr)r�2)��4)��>)��A)��B)���J)��c)�r )rr")r!r$)r#r&)r%r()r'r)r))r'r(r+)r*r-)r,�)�K��a)�r1)r0r
)rr	r)rr)r
r/)r.��)��r3)r2N)�_EXTRA_CASES���6/opt/alt/python-internal/lib/python3.11/re/_casefix.py�<module>r8s���
e�
�I�e��I�	e��I�
e��I�e��I�e���e��I�e� �I�!e�$�I�%e�(�I�)e�,�I�-e�0��1e�4�I�5e�8�I�9e�<�I�=e�@�I�Ae�D�I�Ee�e�H�I�Ie�L�I�Me�P�I�Qe�T�I�Ue�X�I�Ye�\�I�]e�`�I�ae�d�I�ee�h�I�ie�l�I�me�p�I�qe�t�I�ue�x�I�ye�|��}e�@�I�Ae�D�I�Ee�H�I�Ie�e�e�L�I�Me�P�I�Qe�T�I�Ue�X��Ye�\��]e�`�I�ae�d�I�ee�h�I�ie�l�I�me�p�I�qe�t��ue�x�I�ye�|�I�}e�@�I�Ae�D�I�Ee�H�I�Ie�e���r6PKV*]���~JJ*__pycache__/_casefix.cpython-311.opt-1.pycnu�[����

]�)�����>�idd�dd�dd�dd�dd	�d
d�dd
�dd�dd�dd�dd�dd�dd�dd�dd�dd�d d!�id"d#�d$d%�d&d'�d(d)�d*d+�d,d-�d.d/�d0d1�d2d3�d4d5�d6d7�d8d9�d:d;�d<d=�d>d?�d@dA�dBdC��idDdE�dFdG�dHdI�dJdK�dLdM�dNdO�dPdQ�dRdS�dTdU�dVdW�dXdY�dZd[�d\d]�d^d_�d`da�dbdc��ZddS)e�i)�1�s)��)�r)rr)r�E)���)���)���)���)��)��r	)rr
�)��r)r�)���)����)��r)r��)��r)rr)rr)rr)rr)rr)rr)r�2)��4)��>)��A)��B)���J)��c)�r )rr")r!r$)r#r&)r%r()r'r)r))r'r(r+)r*r-)r,�)�K��a)�r1)r0r
)rr	r)rr)r
r/)r.��)��r3)r2N)�_EXTRA_CASES���6/opt/alt/python-internal/lib/python3.11/re/_casefix.py�<module>r8s���
e�
�I�e��I�	e��I�
e��I�e��I�e���e��I�e� �I�!e�$�I�%e�(�I�)e�,�I�-e�0��1e�4�I�5e�8�I�9e�<�I�=e�@�I�Ae�D�I�Ee�e�H�I�Ie�L�I�Me�P�I�Qe�T�I�Ue�X�I�Ye�\�I�]e�`�I�ae�d�I�ee�h�I�ie�l�I�me�p�I�qe�t�I�ue�x�I�ye�|��}e�@�I�Ae�D�I�Ee�H�I�Ie�e�e�L�I�Me�P�I�Qe�T�I�Ue�X��Ye�\��]e�`�I�ae�d�I�ee�h�I�ie�l�I�me�p�I�qe�t��ue�x�I�ye�|�I�}e�@�I�Ae�D�I�Ee�H�I�Ie�e���r6PKV*]�*@Mb�b�)__pycache__/_parser.cpython-311.opt-2.pycnu�[����

o{������	ddlTdZdZed��Zed��Zed��Zed��Zed��Zee	e
eh��Zee
eeeeeh��Zeed	��feed
��feed��feed��feed
��feed��feed��feed��fd�Zeefeefeefeeefgfeeefgfeeefgfeeefgfeeefgfeeefgfee fd�
Z!e"e#e$e%e&e'e(e)d�Z*e'e#ze)zZ+e,e(zZ-dZ.Gd�d��Z/Gd�d��Z0Gd�d��Z1d�Z2d�Z3d�Z4d�Z5d(d �Z6d!�Z7d"�Z8d)d%�Z9d&�Z:d'�Z;d$S)*�)�*z.\[{()*+?^$|z*+?{�
0123456789�01234567�0123456789abcdefABCDEF�4abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZz 	

����
�
�	��\)z\a�\bz\fz\nz\rz\tz\vz\\)
z\Arz\Bz\dz\Dz\sz\Sz\wz\Wz\Z)�i�L�m�s�x�a�t�ulc�D�eZdZd�Zed���Zdd�Zd�Zd�Zd�Z	dS)	�Statec�N�d|_i|_dg|_d|_i|_dS)N�)�flags�	groupdict�groupwidths�lookbehindgroups�grouprefpos��selfs �5/opt/alt/python-internal/lib/python3.11/re/_parser.py�__init__zState.__init__Ms0����
���� �6��� $��������c�*�t|j��S�N)�lenrr"s r$�groupszState.groupsSs���4�#�$�$�$r&Nc��|j}|j�d��|jtkrt	d���|�<|j�|d��}|�t	d|||fz���||j|<|S)Nztoo many groupsz7redefinition of group name %r as group %d; was group %d)r*r�append�	MAXGROUPS�errorr�get)r#�name�gid�ogids    r$�	opengroupzState.opengroupVs����k�������%�%�%��;��"�"��)�*�*�*����>�%�%�d�D�1�1�D����+�.2�C�$�-?�@�A�A�A�#&�D�N�4� ��
r&c�>�|���|j|<dSr()�getwidthr)r#r1�ps   r$�
closegroupzState.closegroupbs�� !�
�
��������r&c�6�||jko|j|duSr()r*r)r#r1s  r$�
checkgroupzState.checkgroupds!���T�[� �F�T�%5�c�%:�$�%F�Fr&c��|j�J|�|��s|�d���||jkr|�d���dSdS)N�cannot refer to an open groupz?cannot refer to group defined in the same lookbehind subpattern)r r9r.)r#r1�sources   r$�checklookbehindgroupzState.checklookbehindgroupgsl��� �,��?�?�3�'�'�
D��l�l�#B�C�C�C��d�+�+�+��l�l�$;�<�<�<�	-�,�,�+r&r()
�__name__�
__module__�__qualname__r%�propertyr*r3r7r9r=�r&r$rrKs�����������%�%��X�%�����-�-�-�G�G�G�<�<�<�<�<r&rc�N�eZdZd
d�Zdd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�ZdS)�
SubPatternNc�8�||_|�g}||_d|_dSr()�state�data�width)r#rFrGs   r$r%zSubPattern.__init__qs%����
��<��D���	���
�
�
r&rc�`�ttf}|jD�]\}}t|dzt	|��zd���|t
ur=t��|D]+\}}t|dzdzt	|��z|���,�p|turYt��t|d��D]4\}}|rt|dzdz��|�|dz���5��|tur_|\}}}	td|��|�|dz��|	r-t|dzdz��|	�|dz����:t|t��r(t��|�|dz����wt||��rd}
|D]h}t|t��r+|
st��|�|dz��d}
�B|
std	d���t|d���d}
�i|
st����td|����dS)
Nz  �)�endr�OR�ELSEFT� )�tuple�listrG�print�str�IN�BRANCH�	enumerate�dump�GROUPREF_EXISTS�
isinstancerD)r#�level�seqtypes�op�avrr�	condgroup�item_yes�item_no�nls           r$rVzSubPattern.dumpxsi���4�=���i�'	�'	�F�B���%��*�s�2�w�w�&�B�/�/�/�/��R�x�x������7�7�E�B���5��7�D�.�3�r�7�7�2�A�6�6�6�6�7��v�������%�b��e�,�,�$�$�D�A�q��1��e�D�j�4�/�0�0�0��F�F�5��7�O�O�O�O�$���&�&�/1�,�	�8�W��b�)�$�$�$��
�
�e�A�g�&�&�&��*��%��*�v�-�.�.�.��L�L��q��)�)�)���B�
�+�+�
���������a�� � � � ��B��)�)�
����
#�
#�A�!�!�Z�0�0�	#�!�$�!�G�G�G����u�Q�w����!���!�/�!�#�2�.�.�.�.��a�R�(�(�(�(�"������G�G�G���b�"�
�
�
�
�O'	�'	r&c�*�t|j��Sr()�reprrGr"s r$�__repr__zSubPattern.__repr__�s���D�I���r&c�*�t|j��Sr()r)rGr"s r$�__len__zSubPattern.__len__�s���4�9�~�~�r&c��|j|=dSr(�rG�r#�indexs  r$�__delitem__zSubPattern.__delitem__�s���I�e���r&c��t|t��r t|j|j|��S|j|Sr()rX�slicerDrFrGrhs  r$�__getitem__zSubPattern.__getitem__�s:���e�U�#�#�	<��d�j�$�)�E�*:�;�;�;��y���r&c��||j|<dSr(rg�r#ri�codes   r$�__setitem__zSubPattern.__setitem__�s����	�%���r&c�<�|j�||��dSr()rG�insertros   r$rszSubPattern.insert�s ���	�����%�%�%�%�%r&c�:�|j�|��dSr()rGr,)r#rps  r$r,zSubPattern.append�s���	��������r&c�n�|j�|jSdx}}|jD�]�\}}|turVt}d}|dD]9}|���\}}t||��}t
||��}�:||z}||z}�e|tur"|���\}}||z}||z}��|tur(|d���\}}||z}||z}��|tvrW|d���\}}|||dzz}|dtkr|r	t}��|||dzz}��!|tvr|dz}|dz}��6|tur!|j
j|\}}||z}||z}��`|turq|d���\}}|d�>|d���\}}t||��}t
||��}nd}||z}||z}���|t urn���t|t��t|t��f|_|jS)Nrr����)rHrGrT�MAXWIDTHr5�min�max�ATOMIC_GROUP�
SUBPATTERN�_REPEATCODES�	MAXREPEAT�
_UNITCODES�GROUPREFrFrrW�SUCCESS)	r#�lo�hir[r\r�j�l�hs	         r$r5zSubPattern.getwidth�s`���:�!��:�����R��i�+	�+	�F�B���V�|�|������Q�%�"�"�B��;�;�=�=�D�A�q��A�q�	�	�A��A�q�	�	�A�A��!�V���!�V����|�#�#��{�{�}�}���1��!�V���!�V����z�!�!��"�v���(�(���1��!�V���!�V����|�#�#��!�u�~�~�'�'���1��!�b��e�)�^���a�5�I�%�%�!�%�!�B�B��a�"�Q�%�i��B�B��z�!�!��!�V���!�V����x����z�-�b�1���1��!�V���!�V�����&�&��!�u�~�~�'�'���1��a�5�$��a�5�>�>�+�+�D�A�q��A�q�	�	�A��A�q�	�	�A�A��A��!�V���!�V����w��������X�&�&��B��(9�(9�9��
��z�r&r(�r)
r>r?r@r%rVrcrerjrmrqrsr,r5rBr&r$rDrDos�����������)�)�)�)�T��������� � � � � � �&�&�&����2�2�2�2�2r&rDc�b�eZdZd�Zd�Zd�Zd�Zd�Zd�Ze	d���Z
d�Zd	�Zdd�Z
d�Zd
S)�	Tokenizerc���t|t��|_||_|jst|d��}||_d|_d|_|���dS)N�latin1r)rXrR�istext�string�decoded_stringri�next�_Tokenizer__next)r#r�s  r$r%zTokenizer.__init__�sZ�� ���-�-�������{�	+����*�*�F�$�����
���	����
�
�
�
�
r&c�2�|j}	|j|}n#t$rd|_YdSwxYw|dkrQ|dz
}	||j|z
}n:#t$r-t	d|jt
|j��dz
��d�wxYw|dz|_||_dS)Nrrzbad escape (end of pattern))rir��
IndexErrorr�r.r�r))r#ri�chars   r$�__nextzTokenizer.__next�s����
��	��&�u�-�D�D���	�	�	��D�I��F�F�	�����4�<�<��Q�J�E�
I���+�E�2�2�����
I�
I�
I��9� �K��T�[�)9�)9�A�)=�?�?�DH�I�
I�����Q�Y��
���	�	�	s�
�,�,�A�7Bc�H�||jkr|���dSdS)NTF�r�r�)r#r�s  r$�matchzTokenizer.matchs&���4�9����K�K�M�M�M��4��ur&c�<�|j}|���|Sr(r�)r#�thiss  r$r/z
Tokenizer.gets���y�����
�
�
��r&c�z�d}t|��D](}|j}||vrn||z
}|����)|S�NrJ)�ranger�r�)r#�n�charset�result�_�cs      r$�getwhilezTokenizer.getwhile	sP�����q���	�	�A��	�A��������a�K�F��K�K�M�M�M�M��
r&c��d}	|j}|���|�@|s|�d|z���|�d|zt|�����||kr|s|�d|zd���n||z
}��|S)NrJTzmissing zmissing %s, unterminated namer)r�r�r.r))r#�
terminatorr0r�r�s     r$�getuntilzTokenizer.getuntils�����	��	�A��K�K�M�M�M��y��8��*�*�Z�$�%6�7�7�7��j�j�!@�:�!M�!$�V���.�.�.��J����;��*�*�Z�$�%6��:�:�:���a�K�F�	��
r&c�>�|jt|jpd��z
Sr��rir)r�r"s r$�posz
Tokenizer.pos"s���z�C��	��R�0�0�0�0r&c�>�|jt|jpd��z
Sr�r�r"s r$�tellzTokenizer.tell%s���z�C��	��R�0�0�0�0r&c�<�||_|���dSr()rir�rhs  r$�seekzTokenizer.seek's����
����
�
�
�
�
r&rc��|js)|�dd���d��}t||j|���|z
��S)N�ascii�backslashreplace)r��encode�decoder.r�r�)r#�msg�offsets   r$r.zTokenizer.error+sP���{�	J��*�*�W�&8�9�9�@�@��I�I�C��S�$�+�t�y�y�{�{�V�';�<�<�<r&c�^�|���s+d|z}|�|t|��|z���|jsd|���sRddl}|�d||���t|��z
|z
fzt|dz���dSdSdS)N�bad character in group name %rrz-bad character in group name %a at position %d���
stacklevel)	�isidentifierr.r)r��isascii�warnings�warnr��DeprecationWarning)r#r0r��nestedr�r�s      r$�checkgroupnamezTokenizer.checkgroupname0s���� � �"�"�	6�2�T�9�C��*�*�S�#�d�)�)�f�"4�5�5�5���	�t�|�|�~�~�	��O�O�O��M�M�?��t�y�y�{�{�S��Y�Y�.��7�8�9�"�v��z�
�
�
�
�
�
�	�	�	�	r&Nr�)r>r?r@r%r�r�r/r�r�rAr�r�r�r.r�rBr&r$r�r��s������������� ���
��������� �1�1��X�1�1�1�1����=�=�=�=�

�
�
�
�
r&r�c��t�|��}|r|St�|��}|r|dtur|S	|dd�}|dkrv||�dt
��z
}t
|��dkr&|�d|zt
|�����tt|dd�d��fS|dkr}|j
rv||�dt
��z
}t
|��d	kr&|�d|zt
|�����tt|dd�d��fS|d
kr�|j
r�||�dt
��z
}t
|��dkr&|�d|zt
|�����t|dd�d��}t|��t|fS|d
kr�|j
r�ddl}|�
d��s|�d���|�dd��}	t|�|����}nL#t"t$f$r8|�d|zt
|��t
d��z��d�wxYwt|fS|t&vrk||�dt&��z
}t|dd�d��}|dkr&|�d|zt
|�����t|fS|t(vrt*�t
|��dkrK|t,vr&|�d|zt
|�����tt|d��fSn#t*$rYnwxYw|�d|zt
|�����)Nrrrwr��incomplete escape %s�r��U��
�N�{�	missing {�}�character name�undefined character name %r�\N{}��.octal escape value %s outside of range 0-0o377�
bad escape %s)�ESCAPESr/�
CATEGORIESrSr��	HEXDIGITSr)r.�LITERAL�intr��chr�unicodedatar�r��ord�lookup�KeyError�	TypeError�	OCTDIGITS�DIGITS�
ValueError�ASCIILETTERS)r<�escaperpr�r��charnames      r$�
_class_escaper�<s����;�;�v���D������>�>�&�!�!�D����Q��2�
�
���1
��1�Q�3�K����8�8��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�b� � ��l�l�#9�F�#B�C��K�K�P�P�P��F�1�2�2�J��#�#�A���F�F�F��A�:��
�#�X�X�&�-�X������<�<��$�$�
0��l�l�;�/�/�/����s�,<�=�=�H�
K���*�*�8�4�4�5�5�����i�(�
K�
K�
K��l�l�#@�8�#K�#&�x�=�=�3�w�<�<�#?�A�A�FJ�K�
K�����A�:��
�)�^�^��f�o�o�a��3�3�3�F��F�1�2�2�J��"�"�A��5�y�y��l�l�$3�5;�$<�=@��[�[�J�J�J��A�:��
�&�[�[����v�;�;�!����L� � ��l�l�?�V�#;�S��[�[�I�I�I��C��q�	�N�N�*�*����
�
�
���
����
�,�,���/��V���
=�
=�=sO�
BN�BN�BN�*AN�<"I�N�A	J(�(N�4A3N�(A-N�
N$�#N$c�	�t�|��}|r|St�|��}|r|S	|dd�}|dkrv||�dt��z
}t|��dkr&|�d|zt|�����tt|dd�d��fS|dkr}|j	rv||�dt��z
}t|��dkr&|�d|zt|�����tt|dd�d��fS|d	kr�|j	r�||�d
t��z
}t|��dkr&|�d|zt|�����t|dd�d��}t|��t|fS|dkr�|j	r�d
dl}|�d��s|�d���|�
dd��}	t|�|����}nL#t t"f$r8|�d|zt|��td��z��d�wxYwt|fS|dkr=||�dt$��z
}tt|dd�d
��fS|t&v�rW|jt&vr�||���z
}|dt$vr�|dt$vrr|jt$vrd||���z
}t|dd�d
��}|dkr&|�d|zt|�����t|fSt|dd���}||jkrW|�|��s#|�dt|�����|�||��t0|fS|�d|zt|��dz
���t|��dkrK|t2vr&|�d|zt|�����tt|d��fSn#t4$rYnwxYw|�d|zt|�����)Nrrwrr�r�r�rr�r�r�r�r�rr�r�r�r�r�r��0r�r�r;�invalid group reference %dr�)r�r/r�r�r�r)r.r�r�r�r�r�r�r�r�r�r�r�r�r�r�r*r9r=r�r�r�)r<r�rFrpr�r�r��groups        r$�_escaper�xs����>�>�&�!�!�D������;�;�v���D�����B
��1�Q�3�K����8�8��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�b� � ��l�l�#9�F�#B�C��K�K�P�P�P��F�1�2�2�J��#�#�A���F�F�F��A�:��
�#�X�X�&�-�X������<�<��$�$�
0��l�l�;�/�/�/����s�,<�=�=�H�
K���*�*�8�4�4�5�5�����i�(�
K�
K�
K��l�l�#@�8�#K�#&�x�=�=�3�w�<�<�#?�A�A�FJ�K�
K�����A�:��
�#�X�X��f�o�o�a��3�3�3�F��C��q�r�r�
�A�.�.�.�.�
�&�[�[��{�f�$�$��&�*�*�,�,�&���1�I��*�*�v�a�y�I�/E�/E��K�9�,�,��f�j�j�l�l�*�F��F�1�2�2�J��*�*�A��5�y�y�$�l�l�,;�=C�,D�+.�v�;�;�8�8�8�#�A�:�%���q�r�r�
�O�O�E��u�|�#�#��'�'��.�.�4� �,�,�'F�'*�6�{�{�4�4�4��*�*�5�&�9�9�9����&��,�,�;�e�C�S��[�[�ST�_�U�U�U��v�;�;�!����L� � ��l�l�?�V�#;�S��[�[�I�I�I��C��q�	�N�N�*�*����
�
�
���
����
�,�,���/��V���
=�
=�=s\�BR(�BR(�BR(�AR(�-"I�R(�A	J�R(�%AR(�(B>R(�'A8R(� BR(�(
R5�4R5c�P�tt�|����Sr()rP�dict�fromkeys)�itemss r$�_uniqr��s����
�
�e�$�$�%�%�%r&c	�:�g}|j}|j}|���}	|t||||dz|o|����|d��sn|s|jt
z}�At
|��dkr|dSt|��}	d}	|D]}
|
sn8|	�	|
d}	�|
d|	krn� |D]}
|
d=�|�|	���C	g}|D]x}
t
|
��dkrn�|
d\}}
|tur|�||
f���C|tur+|
ddtur|�|
���wn+|�tt|��f��|S|�td|ff��|S)NTr�|r)r,r�r��_parser�SRE_FLAG_VERBOSEr)rDr�rS�NEGATE�extendr�rT)r<rF�verboser�r��itemsappend�sourcematch�start�
subpattern�prefix�item�setr[r\s              r$�
_parse_subr��s��
�E��,�K��,�K��K�K�M�M�E�5���F�6�5�'�6�A�:�%�:�3�e�)�5�5�	6�	6�	6��{�3���	���	5��k�$4�4�G�
5��5�z�z�Q����Q�x���E�"�"�J�����
	�
	�D��
����~��a�����a��F�"�"���#�
�
�
����G�G����f�%�%�%��
�
�C������t�9�9��>�>��E��a����B�
��=�=��J�J��B�x� � � � �
�2�X�X�"�Q�%��(�&�0�0��J�J�r�N�N�N�N��E�	���2�u�S�z�z�*�+�+�+������v��e�}�-�.�.�.��r&Fc���t|��}|j}|j}|j}t}	t
}
	|j}|��nZ|dvr�nT|��|r&|tvr�(|dkr	|��}|�|dkrn��D|ddkrt|||��}||���n�|tvr|t|
|��f���n�|dk�r�|���dz
}
g}|j}|jdkr9ddl}|�
d	|���zt|d
z���|d��}	|��}|�+|�d
|���|
z
���|dkr|r�n�|ddkrt!||��}ny|re|dvra|j|krVddl}|�
d|dkrdn|dkrdn	|dkrdnd|���dz
fzt|d
z���t|
|��f}|d���r�|��}|�+|�d
|���|
z
���|dkrE|dt"ur|dd}||��|t|
d��f���nd|ddkrt!||��}nT|dkr<ddl}|�
d|���dz
zt|d
z���t|
|��f}|dtks|dtkr>d|�d|��}|�|t	|��dzt	|��z���|d}|d}||kr>d|�d|��}|�|t	|��dzt	|��z���|t$||ff��n(|dt"ur|dd}||�����t'|��}|	|��dkrJ|ddtur5|r |t(|ddf���n;||d���n(|r|�dt,df��|t"|f���
n�|t.v�r�|���}
|dkrd\}}�n�|dkrdt0}}�n�|dkrdt0}}�ns|dk�rZ|jd kr|t|
|��f�����dt0}}d!x}}|jt2vr||��z
}|jt2v�|d"��r*|jt2vr||��z
}|jt2v�n|}|d ��s2|t|
|��f��|�|
�����|r)t7|��}|t0krt9d#���|rZt7|��}|t0krt9d#���||kr+|�d$|���|
z
���nt;d%|�����|r|d&d�}nd}|r|ddt<ur;|�d'|���|
z
t	|��z���|ddt>vr;|�d(|���|
z
t	|��z���|ddt@ur|dd\}}}}|�|s|s|}|d��rtB|||ff|d&<�n8|d��rtD|||ff|d&<�ntF|||ff|d&<�n|d)kr|tHdf���n�|d*k�r�|���dz
} d}!d+}"d}#d}d}|d���rf|��}|�|�d,���|d-k�rh|d.��r/|�%d/d0��}#|�&|#d|���n|d1��r�|�%d2d0��}#|�&|#d|��|j'�|#��}$|$�+d3|#z}|�|t	|#��dz���|�(|$��s&|�d4t	|#��dz���|�)|$|��|tT|$f�����|��}|�|�d,���|�d5|zt	|��dz���|d6krd+}!�n�|dkrE	|j�+|�d7|���| z
���|��d2krn�B�	��|d8vr�d}%|d.kre|��}|�|�d,���|d9vr)|�d:|zt	|��dz���d&}%|j+}&|&�|j,|_+t[||||dz��}|%dkr	|&�d|_+|d2��s+|�d;|���| z
���|d1kr|t\|%|ff��n|t^|%|ff���
��|d*k�r�|�%d2d0��}'|'�0��r`|�&|'d|��|j'�|'��}(|(�+d3|'z}|�|t	|'��dz����n�	t7|'��}(|(dkrtb�n:#tb$r-d<|'z}|�|t	|'��dz��d�wxYw|(s&|�d=t	|'��dz���|(tdkr+d>|(z}|�|t	|'��dz���|(|j3vr/|���t	|'��z
dz
|j3|(<|'�4��r|'�5��sqddl}|�
d?|j6rto|'��ntq|'��|���t	|'��z
dz
fztr|d
z���|�)|(|��tu||||dz��})|�d@��r6tu||||dz��}*|jd@kr|�dA���nd}*|�d2��s+|�d;|���| z
���|tv|(|)|*ff���
�o|d/krd+}!d}"n�|txvs|dkr[t{|||��}+|+�@|r|r+|�dB|���| z
���|j>t~z}�
��|+\}}d+}!n)|�dC|zt	|��dz���|!rU	|�@|#��}n@#t$r1},|�|,jAt	|#��dz��d�d},~,wwxYwd}|s
|t~zo
|t~z}-t[|||-|dz��}|�d2��s+|�d;|���| z
���|�|�B||��|"r|t�|f��ne|t@||||ff��nN|dkr|t<t�f��n0|dDkr|t<t�f��nt;dE|�������et�t	|����ddd&�D]-}.||.\}/}0|/t@ur|0\}}}}|�|s|s
|||.|.dz�<�.|S)FNTz|)�#rrr�[rz"Possible nested set at position %dr�r��^zunterminated character set�]z-&~|zPossible set %s at position %d�-�
difference�&�intersection�~zsymmetric difference�unionz&Possible set difference at position %drwzbad character range �?)rrr�+r�r�rJ�,z"the repetition number is too largez"min repeat greater than max repeatzunsupported quantifier rvznothing to repeatzmultiple repeat�.�(Fzunexpected end of pattern�P�<�>�
group name�=�)�unknown group name %rr;zunknown extension ?P�:zmissing ), unterminated commentz=!<z=!zunknown extension ?<z"missing ), unterminated subpatternr�zbad group numberr��-bad character in group name %s at position %dr�z/conditional backref with more than two branchesz/global flags not at the start of the expressionzunknown extension ?�$zunsupported special character )GrDr,r/r�r)r�r��
WHITESPACEr��
SPECIAL_CHARSr�r�r�r��
FutureWarningr.r�rS�RANGEr��NOT_LITERALrsr��REPEAT_CHARSr~r�r�r��
OverflowError�AssertionError�ATr}r|�
MIN_REPEAT�POSSESSIVE_REPEAT�
MAX_REPEAT�ANYr�r�rr9r=r�r r*r��ASSERT�
ASSERT_NOTr�r�r-r!�	isdecimalr�r�rbr�r�r�rW�FLAGS�_parse_flagsrr�r3r�r7r{�AT_BEGINNING�AT_ENDr�)1r<rFr�r��firstr��subpatternappend�	sourcegetr��_len�_ordr�rp�herer��	setappendr��negate�code1�that�code2r�r�r�ryrzr�r�r��	add_flags�	del_flagsr6r��capture�atomicr0r1�dirr �condnamer]r^r_r�err�sub_verboserr[r\s1                                                 r$r�r�s����E�"�"�J�"�(���
�I��,�K��D��D�lO��{���<���4�<�<���	�����		��z�!�!���s�{�{��$�9�;�;�D��|�t�t�|�|������7�d�?�?��6�4��/�/�D���T�"�"�"�"�
��
&�
&���g�t�t�D�z�z�2�3�3�3�3�
�S�[�[��;�;�=�=�1�$�D��C��
�I��{�c�!�!������
�
�8�6�;�;�=�=�H�!�f�q�j�����!�[��%�%�F�9
%� �y�{�{���<� �,�,�'C�'-�{�{�}�}�t�';�=�=�=��3�;�;�3�;���!�W��_�_�)�&�$�7�7�E�E��
�t�v�~�~�&�+��2E�2E�'���� �
�
�<�04������26�#�+�+���:>�#�+�+� 6� 6� '� &���
�
�� 1�@3�3�*�f�q�j�&����$�T�T�$�Z�Z�/�E��;�s�#�#�#%�$�9�;�;�D��|�$�l�l�+G�+1�;�;�=�=�4�+?�A�A�A��s�{�{� ��8�r�>�>�$)�!�H�Q�K�E�!�	�%�(�(�(�!�	�7�D�D��I�I�"6�7�7�7���A�w�$��� -�f�d� ;� ;����3�;�;�+�O�O�O�$�M�M� H�$*�K�K�M�M�A�$5�!7� -�&�1�*�*����
!(���d��� 3���Q�x�7�*�*�e�A�h�'�.A�.A��=A�T�T�4�4�H��$�l�l�3��D�	�	�A�
��D�	�	�0I�J�J�J��q��B��q��B��B�w�w�w�=A�T�T�4�4�H��$�l�l�3��D�	�	�A�
��D�	�	�0I�J�J�J��I�u�r�2�h�/�0�0�0�0��Q�x�2�~�~� %�a������I�e�$�$�$�s9
%�v��*�*�C��t�C�y�y�A�~�~�#�a�&��)�w�"6�"6��-�$�$�k�3�q�6�!�9�%=�>�>�>�>�$�$�S��V�,�,�,�,��2��J�J�q�6�4�.�1�1�1�!� �"�c��+�+�+�+�
�\�
!�
!��;�;�=�=�D��s�{�{����S�S������i�S��������i�S��������;�#�%�%�$�$�g�t�t�D�z�z�%:�;�;�;���i�S�����R��k�V�+�+��)�)�+�+�%�B��k�V�+�+��;�s�#�#�� �+��/�/��i�i�k�k�)��!�+��/�/���B�"�{�3�'�'��$�$�g�t�t�D�z�z�%:�;�;�;��K�K��%�%�%���R��b�'�'�C��i�'�'�+�,P�Q�Q�Q��A��b�'�'�C��i�'�'�+�,P�Q�Q�Q��S�y�y�$�l�l�+O�+1�;�;�=�=�4�+?�A�A�A��%�n�D�D�%J�K�K�K��
�!�"�#�#�������
E�4��7�1�:��+�+��l�l�#6�#)�;�;�=�=�4�#7�#�d�)�)�#C�E�E�E��A�w�q�z�\�)�)��l�l�#4�#)�;�;�=�=�4�#7�#�d�)�)�#C�E�E�E��A�w�q�z�Z�'�'�15�a����.��y�)�Q��=��=�9�=��D��{�3���
@�",�s�C��.>�!?�
�2�����S�!�!�
@�"3�c�3��5E�!F�
�2���#-�s�C��.>�!?�
�2���
�S�[�[���c�4�[�)�)�)�)�
�S�[�[��K�K�M�M�A�%�E��G��F��D��I��I��{�3���L
6� �y�{�{���<� �,�,�'B�C�C�C��3�;�;�"�{�3�'�'�:�%���s�L�A�A���-�-�d�A�v�>�>�>�>�$��S�)�)�:�%���s�L�A�A���-�-�d�A�v�>�>�>�#�o�1�1�$�7�7���;�"9�D�"@�C�"(�,�,�s�C��I�I��M�"B�"B�B�$�/�/��4�4�>�"(�,�,�/N�/2�4�y�y�1�}�#>�#>�>��2�2�3��?�?�?�(�(�(�C��9�9�9� � )�y�{�{���<�"(�,�,�/J�"K�"K�K�$�l�l�+A�D�+H�+.�t�9�9�q�=�:�:�:��S�[�[�#�G�G��S�[�[�"�!�;�.�"(�,�,�/P�/5�{�{�}�}�u�/D�#F�#F�F�$�9�;�;�#�-�-�!�"���U�]�]��C��s�{�{�(�y�{�{���<�"(�,�,�/J�"K�"K�K��t�+�+�"(�,�,�/E��/L�/2�4�y�y�1�}�#>�#>�>� ��+0�+A�(�+�3�5:�\�E�2�"�6�5�'�6�A�:�F�F�A��Q�w�w�+�3�59�E�2�&�;�s�+�+�B�$�l�l�+O�+1�;�;�=�=�5�+@�B�B�B��s�{�{�(�(�&�3��(�);�<�<�<�<�(�(�*�s�A�h�)?�@�@�@���S�[�[�%���s�L�A�A�H��,�,�.�.���-�-�h��6�B�B�B�$)�O�$7�$7��$A�$A�	�$�,�"9�H�"D�C�"(�,�,�s�C��M�M�A�4E�"F�"F�F�-�Q�(+�H�
�
�I�(�1�}�}�&0� 0� -��)�Q�Q�Q�"B�X�"M�C�"(�,�,�s�C��M�M�A�4E�"F�"F�D�P�Q���� )�B�"(�,�,�/A�/2�8�}�}�q�/@�#B�#B�B�$�	�1�1�">��"J�C�"(�,�,�s�C��M�M�A�4E�"F�"F�F�$�E�,=�=�=� &���
�
��H�
�
� =�� A�"�-�i�8�!)� 2� 2� 4� 4���9I�9I�9K�9K��+�O�O�O�$�M�M� O�39�=�!U��h����e�H�o�o�!'������X���!>��!B�!D�!D�!3�v��z�	*�����.�.�y�&�A�A�A�%�f�e�W�f�q�j�I�I�H��|�|�C�(�(�'�"(�����!��"L�"L��!�;�#�-�-�"(�,�,�/`�"a�"a�a�.�#'��!�<�<��,�,�B�$�l�l�+O�+1�;�;�=�=�5�+@�B�B�B�$�$�o�	�8�W�7U�%V�W�W�W���S�[�[�#�G�!�F�F��U�]�]�d�c�k�k�(����=�=�E��}�$�F�
�F�"(�,�,�0C�/5�{�{�}�}�u�/D�#F�#F�F�#(�+�0@�"@�� �+0�(�I�y�#�G�G� �,�,�'<�t�'C�'*�4�y�y�1�}�6�6�6��
�I�!�O�O�D�1�1�E�E���I�I�I� �,�,�s�w��D�	�	�A�
�>�>�D�H�����I������#�E�	�4D�(D�>� )�,<� <�=�
��6�5�+�v��z�B�B�A��<�<��$�$�
:��l�l�#G�#)�;�;�=�=�5�#8�:�:�:�� �� � ���*�*�*��
Q� � �,��!2�3�3�3�3� � �*�u�i��A�.N�!O�P�P�P�P�
�S�[�[���b�,�/�0�0�0�0�
�S�[�[���b�&�\�*�*�*�*�!�.�t�t�!M�N�N�N�YlO�^�3�z�?�?�
#�
#�D�D�b�D�
)�'�'���A����B�
����-/�*�E�9�i���}�Y�}�y�}�%&�
�1�a��c�6�"���s$�
m*�*7n!�y�
z�#,z�zc�
�|j}d}d}|dkr�	t|}|jr|dkrd}|�|���n|dkrd}|�|���||z}|tzr%|tz|krd}|�|���|��}|�|�d	���|d
vrnE|tvr;|���rdnd	}|�|t
|�������|dkr|xj|zc_dS|tzr|�d
d���|dk�r|��}|�|�d���|tvr;|���rdnd}|�|t
|�����	t|}|tzrd}|�|���||z}|��}|�|�d���|dkrnE|tvr;|���rdnd}|�|t
|�������|tzr|�dd���||zr|�dd���||fS)NrrTrz8bad inline flags: cannot use 'L' flag with a str patternrz:bad inline flags: cannot use 'u' flag with a bytes patternz9bad inline flags: flags 'a', 'u' and 'L' are incompatiblezmissing -, : or )z)-:zunknown flagrz,bad inline flags: cannot turn on global flagrzmissing flagz8bad inline flags: cannot turn off flags 'a', 'u' and 'L'z	missing :rz-bad inline flags: cannot turn off global flagz(bad inline flags: flag turned on and off)	r/r'r�r.�
TYPE_FLAGS�isalphar)r�GLOBAL_FLAGS)r<rFr�r-r6r7�flagr�s        r$r(r(�s����
�I��I��I��s�{�{�	3���;�D��}�
,��3�;�;�T�C� �,�,�s�+�+�+���3�;�;�V�C� �,�,�s�+�+�+����I��z�!�
(�	�J�(>�4�'G�'G�Q���l�l�3�'�'�'��9�;�;�D��|��l�l�#6�7�7�7��u�}�}���5� � �(,�����O�n�n�<O���l�l�3��D�	�	�2�2�2�+	3�,�s�{�{�
���y� ����t��<��N��l�l�I�1�M�M�M��s�{�{��y�{�{���<��,�,�~�.�.�.��u���$(�L�L�N�N�F�.�.��C��,�,�s�C��I�I�.�.�.�
	3���;�D��j� �
(�P���l�l�3�'�'�'����I��9�;�;�D��|��l�l�;�/�/�/��s�{�{���5� � �(,�����G�n�n�K���l�l�3��D�	�	�2�2�2�
	3��<��O��l�l�J�A�N�N�N��9��J��l�l�E�q�I�I�I��i��r&c�8�t|t��rH|tzrtd���|tzs|t
z}nV|t
zrtd���n<|t
zrtd���|tzr|tzrtd���|S)Nz)cannot use LOCALE flag with a str patternz(ASCII and UNICODE flags are incompatiblez,cannot use UNICODE flag with a bytes patternz'ASCII and LOCALE flags are incompatible)rXrR�SRE_FLAG_LOCALEr��SRE_FLAG_ASCII�SRE_FLAG_UNICODE)�srcrs  r$�	fix_flagsrH�s����#�s���H��?�"�	J��H�I�I�I��~�%�	I��%�%�E�E�
�%�
%�	I��G�H�H�H�	I��#�#�	M��K�L�L�L��?�"�	H�u�~�'=�	H��F�G�G�G��Lr&rNc���t|��}|�t��}||_||_t	|||t
zd��}t
||jj��|j_|j�|�	d���|jj
D]8}||jjkr&d|z}t|||jj
|����9|tzr|�
��|S)Nrzunbalanced parenthesisr�)r�rrrRr�r�rHrFr�r.r!r*�SRE_FLAG_DEBUGrV)rRrrFr<r6�gr�s       r$�parserL�s����s�^�^�F��}������E�K��E�I��6�5�%�*:�":�A�>�>�A��c�1�7�=�1�1�A�G�M�
�{���l�l�3�4�4�4�
�W�
 �:�:��������.��2�C���S�!�'�"5�a�"8�9�9�9��
�~���	�������Hr&c	����
���t|����j}g�g�g�
�
j}��
���fd�}�j}	|��}|��n�|ddk�r�|d}|dk�rՉ�d��s��d�����d	d
��}|���rC��|dd��	||}	�nA#t$rtd|z��d�wxYw	t|��}	|	dkrt�n8#t$r+��d
|zt|��dz��d�wxYw|	tkr)��d|	zt|��dz���|���r|���snddl}
|
�d�jrt)|��nt+|������t|��z
dz
fzt.d���||	t|��dz���n�|dkri�jt2vr(||��z
}�jt2vr
||��z
}|t5t|dd�d��dz�����nd|t6vr�d}�jt6vr�||��z
}|t2vr�|dt2vry�jt2vrk||��z
}d}t|dd�d��}|dkr&��d|zt|�����|t5|����|s1|t|dd���t|��dz
��ny	t5t8|d��}n@#t$r3|t:vr'��d|zt|����d�YnwxYw||��n||����ԉ
r(��d��
����t?|t@��sd��D�����fS)Nc� ��|�jkr��d|z|����r-��d�������dd�=��t	���|f����d��dS)Nr�rJ)r*r.r,�joinr))rir�r*�literal�literalsrrFs  �����r$�addgroupz parse_template.<locals>.addgroup�s�����5�<����'�'�6��>��D�D�D��	��O�O�B�G�G�G�,�,�-�-�-�����
��
�
�s�8�}�}�e�,�-�-�-���������r&TrrrrKrz	missing <rrrvrr�r�r�r�r�r�r�Frwr�r�rJc�@�g|]}|�dn|�d����S)Nzlatin-1)r�)�.0rs  r$�
<listcomp>z"parse_template.<locals>.<listcomp>Hs,��Q�Q�Q�1�A�I�D�D�1�8�8�I�+>�+>�Q�Q�Qr&)!r�r/r,�
groupindexr�r.r�r�r�r�r�r�r�r)r-r&r�r�r�r�rbr�r�r�r�r�r�r�r�r�rOrXrR)r<rF�sget�lappendrRrWr�r�r0rir��isoctalr*rPrQrs `          @@@@r$�parse_templater[�s��������	�&���A��5�D�
�F��H��G��n�G�����������!�J�B��t�v�v���<����7�d�?�?��Q��A��C�x�x��w�w�s�|�|�/��'�'�+�.�.�.��z�z�#�|�4�4���$�$�&�&���$�$�T�1�b�1�1�1�S� *�4� 0����#�S�S�S�(�)@�4�)G�H�H�d�R�S����?� #�D�	�	�� �1�9�9�",�,�%��%�?�?�?��g�g�&F��&M�&)�$�i�i�!�m�5�5�:>�?�?�����	�)�)��g�g�&B�U�&J�&)�$�i�i�!�m�5�5�5� �N�N�,�,��������'���� �
�
�K�+,�8�D�T�$�Z�Z�Z��t����V�V�X�X��D�	�	�1�A�5�7�7�/�1�	&��������D�	�	�A�
�.�.�.�.��c����6�Y�&�&��D�D�F�F�N�D��v��*�*�����������C��Q�R�R��!�,�,�t�3�4�4�5�5�5�5��f������6�V�#�#��D�D�F�F�N�D��Y���4��7�i�+?�+?���)�+�+��������"&����Q�R�R��!�,�,���u�9�9�"#�'�'�+:�<@�+A�BE�d�)�)�#M�#M�M����A�������;��H�S��a�b�b��]�]�C��I�I��M�:�:�:��S��w�t�}�Q�/�0�0�D�D���S�S�S��L�(�(��g�g�o��&<�c�$�i�i�H�H�d�R�)�(�S�������
�
�
�
��G�D�M�M�M�EB�F�*��������(�(�)�)�)��f�c�"�"�R�R�Q��Q�Q�Q���8��s*�C�C8�<D�5E� N5�5:O2�1O2c���|j}|jdd�}|\}}|dd�}	|D]\}}||��p|||<�n!#t$rtd|z��d�wxYw|�|��S)Nrr�)r�r�r�r.rO)�templater�rK�emptyr*rQrir�s        r$�expand_templater_Ks���
��A��L��!���E���F�H�����{�H�D�"�	0�	0�L�E�5��a��h�h�/�%�H�U�O�O�	0���D�D�D��0�5�8�9�9�t�C�D�����:�:�h���s�A�A)F)rN)<�
_constantsrr�	frozensetr�r�r�r�rr r"r!r}r#rrSr�r�CATEGORYrr�r�r�AT_BEGINNING_STRING�AT_BOUNDARY�AT_NON_BOUNDARY�CATEGORY_DIGIT�CATEGORY_NOT_DIGIT�CATEGORY_SPACE�CATEGORY_NOT_SPACE�
CATEGORY_WORD�CATEGORY_NOT_WORD�
AT_END_STRINGr��SRE_FLAG_IGNORECASErD�SRE_FLAG_MULTILINE�SRE_FLAG_DOTALLr�rE�SRE_FLAG_TEMPLATErFr'r?rJrArxrrDr�r�r�r�r�r�r(rHrLr[r_rBr&r$�<module>rqsQ��&������
���	��<�	 �	 ���I�j�!�!�	��I�.�/�/�	��y�O�P�P��
�Y�}�
%�
%�
��y�*�j�2C�D�E�E��
�Y��U�B���h�G�
H�
H�
�
�S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y��	�	��
�#�$������ ��(�N�+�,�-��(�.�/�0�1��(�N�+�,�-��(�.�/�0�1��(�M�*�+�,��(�-�.�/�0��
����
�
�	�	�	�	�	�	�	�	�	���o�
-�0@�
@�
�� 1�1����"<�"<�"<�"<�"<�"<�"<�"<�Hu�u�u�u�u�u�u�u�nT�T�T�T�T�T�T�T�l:>�:>�:>�xK>�K>�K>�Z&�&�&�:�:�:�xA�A�A�A�F: �: �: �x��� 
�
�
�
�6[�[�[�z
 �
 �
 �
 �
 r&PKV*](nmd2y2y+__pycache__/_compiler.cpython-311.opt-2.pycnu�[����

A��k�������	ddlZddlmZddlTddlmZeehZe	e
hZee
hZeeehzZeeeefeeeefeee	efiZejfd�Zd�Zd�Zdd	�Z ej!d
zZ"de"zdz
Z#dZ$e"e%fd�Z&d
�Z'd�Z(d�Z)d�Z*d�Z+d�Z,d�Z-d�Z.d�Z/d�Z0d�Z1dd�Z2dS)�N�)�_parser)�*)�_EXTRA_CASESc�*�||zr||z}||z|zS�N�)�flags�	add_flags�	del_flags�
TYPE_FLAGSs    �7/opt/alt/python-internal/lib/python3.11/re/_compiler.py�_combine_flagsrs-���:���
�*�����I��)��+�+�c
��|j}t}t}t}t}t
}d}	d}
d}|tzrL|tzsB|tzr tj
}	tj}
t}ntj
}	tj}
|D�]=\}}
||v�rP|tzs||��||
���,|tzr"|t|��||
���X|	|
��s||��||
���z|
|
��}|s"|t |��||����||vr"|t"|��||����|t$��||��}|d��|t&ur|t(��|f||zD]}|t*��||���|t,��||��|z
||<��[|t.ur�t1|
|	|
|��\}}|tzr|tzr|t2��n6|s|t.��n#|s|t4��n|t$��||��}|d��t7|||��||��|z
||<��|t8ur.|t:zr|t<����3|t8����E||v�rJ|t>zrtAd|�����tC|
d��r�|||d��||��}|d��||
d��||
d��tE||
d|��|tF��||��|z
||<��|||d��||��}|d��||
d��||
d��tE||
d|��||��|z
||<|||d�����|tHurr|
\}}}}|r!|tJ��||dz
dz��tE||tM|||����|r$|tJ��||dz
dzdz����|tNurZ|tN��||��}|d��tE||
|��|tF��||��|z
||<��r||vr
||�����||vr�||��||��}|d��|
ddkr|d��nW|
d�(��\}}|tRkrtAd���||krtAd���||��tE||
d|��|tF��||��|z
||<��Q|tTur�||��|tVzrtX�-|
|
��}
|tzrt\�-|
|
��}
n%|tzrt^�-|
|
��}
||
�����|t`ur�||��g}|j}|
dD]i}
||��}|d��tE||
|��|tb��|||����|d��||��|z
||<�j|t,��|D]}||��|z
||<����|tdurG||��|tzrtf|
}
n|tzr
th|
}
||
�����|tjurd|tzs||��n>|tzr|tl��n#|s|tn��n|tp��||
dz
����V|trur�||��||
ddz
��||��}|d��tE||
d|��|
drd|tb��||��}|d��||��|z
dz||<tE||
d|��||��|z
||<��||��|z
dz||<��-tAd|�����dS)Nrz(internal: unsupported template operator �rzlooks too much behindz(look-behind requires fixed-width patternz#internal: unsupported operand type ):�append�len�_LITERAL_CODES�_REPEATING_CODES�_SUCCESS_CODES�
_ASSERT_CODES�SRE_FLAG_IGNORECASE�SRE_FLAG_LOCALE�SRE_FLAG_UNICODE�_sre�unicode_iscased�unicode_tolowerr�
ascii_iscased�
ascii_tolower�OP_LOCALE_IGNORE�	OP_IGNORE�OP_UNICODE_IGNORE�
IN_UNI_IGNORE�NOT_LITERAL�NEGATE�LITERAL�FAILURE�IN�_optimize_charset�
IN_LOC_IGNORE�	IN_IGNORE�_compile_charset�ANY�SRE_FLAG_DOTALL�ANY_ALL�SRE_FLAG_TEMPLATE�error�_simple�_compile�SUCCESS�
SUBPATTERN�MARKr�ATOMIC_GROUP�getwidth�MAXCODE�AT�SRE_FLAG_MULTILINE�AT_MULTILINE�get�	AT_LOCALE�
AT_UNICODE�BRANCH�JUMP�CATEGORY�	CH_LOCALE�
CH_UNICODE�GROUPREF�GROUPREF_LOC_IGNORE�GROUPREF_IGNORE�GROUPREF_UNI_IGNORE�GROUPREF_EXISTS)�code�patternr
�emit�_len�
LITERAL_CODES�REPEATING_CODES�
SUCCESS_CODES�ASSERT_CODES�iscased�tolower�fixes�op�av�lo�skip�k�charset�hascased�grouprr�p�hi�tail�
tailappend�skipyes�skipnos                            rr4r4%s�	���;�D��D�"�M�&�O�"�M� �L��G��G��E��"�"�)�5�?�+B�)��#�#�	)��*�G��*�G� �E�E��(�G��(�G��^I�^I���B�
�����.�.�
3���R������R�������(�
3���%�b�)�*�*�*���R������W�R�[�[�
3���R������R������W�R�[�[���3��D��2��'�'�'��D��H�H�H�H��u�_�_��D�*�2�.�/�/�/��D��H�H�H�H��D��'�'�'��4��:�:�D�t�t�A�w�w�w��[�(�(���V���� �U�U�2�Y�.� � ����W�
�
�
���Q������D��M�M�M�!%��d���d�!2�D��J�J�
�2�X�X� 1�"�g�w�� N� N��G�X��*�*�
$�u��/F�
$���]�#�#�#�#��
$���R������
$���Y�������]�#�#�#��4��:�:�D�t�t�A�w�w�w��W�e�T�2�2�2���d���d�*�D��J�J�
�3�Y�Y���&�
���W�
�
�
�
���S�	�	�	�	�
�?�
"�
"��(�(�
R��e�B�B�P�Q�Q�Q��r�!�u�~�~�
-���_�R�(��+�,�,�,��t�D�z�z��4�4��7�7�7���R��U������R��U������r�!�u�e�,�,�,���W�
�
�
�!�T�$�Z�Z�$�.��T�
�
���_�R�(��+�,�,�,��t�D�z�z��4�4��7�7�7���R��U������R��U������r�!�u�e�,�,�,�!�T�$�Z�Z�$�.��T�
���_�R�(��+�,�,�,�,�
�:�
�
�-/�*�E�9�i���
"���T�
�
�
���e�A�g�q�[�!�!�!��T�1�n�U�I�y�I�I�J�J�J��
$���T�
�
�
���e�A�g�q�[��]�#�#�#��
�<�
�
�
�D������4��:�:�D�t�t�A�w�w�w��T�2�u�%�%�%��D��M�M�M���d���d�*�D��J�J�
�=�
 �
 ��D��H�H�H�H�
�<�
�
��D��H�H�H��4��:�:�D�t�t�A�w�w�w��!�u��z�z���Q������A����)�)���B���<�<�� 7�8�8�8���8�8�� J�K�K�K���R�����T�2�a�5�%�(�(�(��D��M�M�M���d���d�*�D��J�J�
�2�X�X��D��H�H�H��)�)�
.�!�%�%�b�"�-�-����&�
,��]�]�2�r�*�*����)�)�
,��^�^�B��+�+���D��H�H�H�H�
�6�\�\��D��H�H�H��D���J���e�
/�
/���t�D�z�z��4�4��7�7�7���r�5�)�)�)���T�
�
�
��
�4�4��:�:�&�&�&���Q����!�T�$�Z�Z�$�.��T�
�
��D��M�M�M��
/�
/��!�T�$�Z�Z�$�.��T�
�
�
/�
�8�^�^��D��H�H�H���&�
$��r�]����)�)�
$���^���D��H�H�H�H�
�8�^�^��.�.�
*���R�������(�
*���(�)�)�)�)��
*���_�%�%�%�%���(�)�)�)��D��A��J�J�J�J�
�?�
"�
"��D��H�H�H��D��A��q��M�M�M��d�4�j�j�G�$�$�q�'�'�'��T�2�a�5�%�(�(�(��!�u�
9���T�
�
�
���d����T�T�!�W�W�W� $��T�
�
�W� 4�q� 8��W�
���r�!�u�e�,�,�,�#�t�D�z�z�F�2��V��� $��T�
�
�W� 4�q� 8��W�
�
��%�2�2�G�H�H�H�}^I�^Irc�P�|j}|D�]
\}}||��|tur�|tur||���0|tus	|tur#||d��||d���e|t
ur|�|����|tur|�|����|turN|tzr|t|����|tzr|t|����||����td|�����|t��dS)Nrrz#internal: unsupported set operator )rr&r'�RANGE�RANGE_UNI_IGNORE�CHARSET�extend�
BIGCHARSETrCrrDrrEr2r()r[r
rKrMrVrWs      rr-r-�sD���;�D��I�I���B���R����
��<�<��
�7�]�]��D��H�H�H�H�
�5�[�[�B�"2�2�2��D��A��K�K�K��D��A��K�K�K�K�
�7�]�]��K�K��O�O�O�O�
�:�
�
��K�K��O�O�O�O�
�8�^�^���&�
���Y�r�]�#�#�#�#��)�)�
���Z��^�$�$�$�$���R������%�2�2�G�H�H�H��D��M�M�M�M�Mrc�l�g}g}td��}d}|D�]}\}}			|tur>|r6||	��}
d||
<|r|
|vr||
D]}d||<�|s
||	��rd}n�d||	<n�|tur�t|	d|	ddz��}|rg|r-t	||��D]}
d||
<|
|vr||
D]}d||<��nt	||��D]}
d||
<�|stt	||����}nC|D]}
d||
<�n8|tur|�||	f��n|�||	f��nY#t$rLt|��dkr|ddzz
}Y��F|rd}|turt}|�||	f��YnwxYw��g}d}	|�d|��}|dkrnot|��dkrd}nY|�d|��}|dkr%|�|t|��f��n|�||f����|�~|D]L\}}||z
dkr|�t|f���+|�t||dz
ff���M||z
}|s t|��t|��kr||fS||fSt|��dkr4t|��}|�t|f��||z
}||fSt|��}i}td��}d}t��}tdd	d��D]9}
||
|
dz�}||vr||||
dz<�"|x||
dz<||<|dz
}||z
}�:t|��}|gt|��z|dd�<|�t |f��||z
}||fS)
N�FTrr�i�ri)�	bytearrayr're�range�map�anyr&r�
IndexErrorrrf�find�
_mk_bitmaprg�bytes�_bytes_to_codesri)r[rS�fixuprU�outr`�charmapr\rVrWrXrZ�r�i�runs�qr^�data�comps�mapping�block�chunks                      rr*r*�s���
�C�
�D���n�n�G��H��9�9���B�8	�6
&���=�=��	(�"�U�2�Y�Y��&'���� �/�R�5�[�[�%*�2�Y�/�/��-.���
�
�'�,�G�G�B�K�K�,�'+�H��&'������5�[�[��b��e�R��U�1�W�-�-�A��+� �/�%(���]�]�7�7��-.���
�#$��:�:�-2�1�X�%7�%7��56���
�
��	7�&)���]�]�/�/��-.���
�
�'�<�'*�3�w��?�?�';�';�H��!"�+�+�A�)*�G�A�J�J�+��6�\�\��J�J��B�x�(�(�(�(��K�K��R��)�)�)����
&�
&�
&��w�<�<�3�&�&��u�v�~�-�G��H��.�#�H��U�{�{�-�����R��H�%�%�%�%�%�+
&����,
��D�	�A���L�L��A�����q�5�5���t�9�9��>�>��D���L�L��A�����q�5�5��K�K��C��L�L�)�*�*�*�����Q��F��������	0�	0�D�A�q��1�u��z�z��
�
�G�Q�<�(�(�(�(��
�
�E�A�q�1�u�:�.�/�/�/�/��t����	!�s�3�x�x�#�g�,�,�.�.���=� ��� � ��7�|�|�s����'�"�"���
�
�G�T�?�#�#�#��t����H�}��,�G�n�n�G��E���n�n�G�
�E��;�;�D�
�1�e�S�
!�
!������1�s�7�
�#���E�>�>� %�e��G�A��H���/4�4�G�A��H���e���Q�J�E��E�M�D�D��d���D���/�'�2�2�2�D��1��I��J�J�
�D�!�"�"�"��4�K�C���=�s�DD<�<%F�$+F�F�s0111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111c�����|�t��ddd�����fd�tt���d���D��S)N���c�>��g|]}��|�z
|�d����S)rr	)�.0rz�	_CODEBITS�_int�ss  ���r�
<listcomp>z_mk_bitmap.<locals>.<listcomp>�sC���3�3�3��
�D��1�y�=�!�#�$�a�(�(�3�3�3rr)�	translate�_BITS_TRANSrnr)�bitsr�r�r�s ``@rrsrs�sj��������{�#�#�D�D�b�D�)�A�3�3�3�3�3�3��3�q�6�6�1�y�j�1�1�3�3�3�3rc�n�t|���d��}|���S)N�I)�
memoryview�cast�tolist)�b�as  rruru�s+���1�
�
���3���A�
�8�8�:�:�rc��t|��dkrdS|d\}}|tur|dduot|d��S|tvS)NrFrr�)rr6r3�_UNIT_CODES)r^rVrWs   rr3r3�sV��
�1�v�v��{�{��u�
�q�T�F�B��	�Z����!�u��}�0���B����0�
���rc�
�	dgt|��z}tdt|����D]P}||dz
}||||kr)|dkrd||<n%||dz
}||||k�)|dz||<�Q|S)Nrr)rrn)�prefix�tablerz�idxs    r�_generate_overlap_tabler��s�����C�#�f�+�+��E�
�1�c�&�k�k�
"�
"�����A��E�l���Q�i�6�#�;�&�&��a�x�x���a�����a��.�C�	�Q�i�6�#�;�&�&��Q�w�E�!�H���Lrc�^�|tzsdS|tzrtjStjSr)rrrrr)r
s r�_get_iscasedr��s5���&�&�"��t�	�!�	!�"��#�#��!�!rc���g}|j}d}t|��}|jD]�\}}|tur|r
||��rn�||���)|tur�|\}}	}
}t||	|
��}|tzr|tzrn]t||��\}
}}|�&|�t|��}n|�t|��|z}|�
|
��|sn��n||dfS||dfS)NTF)rr�r}r'r6rrr�_get_literal_prefixrrh)rLr
r��prefixappend�prefix_skiprSrVrWr]rrr^�flags1�prefix1�prefix_skip1�got_alls                rr�r��s@��
�F��=�L��K��5�!�!�G��,�)�)���B�
��=�=��
�7�7�2�;�;�
����L������
�:�
�
�-/�*�E�9�i��#�E�9�i�@�@�F��+�+�
���0H�
���-@��F�-K�-K�*�G�\�7��"��$�"%�f�+�+�K�K�!�-�"%�f�+�+��"<�K��M�M�'�"�"�"��
���
�
�E��{�D�(�(��;��%�%rc��	|jsdS|jd\}}|turn/|\}}}}t|||��}|tzr|tzrdS�Rt|��}|tur|r
||��rdS||fgS|turLg}|j}	|dD]8}
|
sdS|
d\}}|tur|r||��s|	||f���6dS|S|tur{|}|ru|D]r\}}|tur||��rdS�|turL|ddkrdStt|t|d|ddz������rdS�s|SdS)NTrri��)r}r6rrrr�r'rArr)rerprorn)rLr
rVrWr]rrrSr[�
charsetappendr^s           r�_get_charset_prefixr��s���	��|�	��4���a����B�
�Z����/1�,��y�)�W��u�i��;�;���&�&�	�5�?�+B�	��4�	��5�!�!�G�	�W�}�}��	�w�w�r�{�{�	��4��R��z��	�v�������
��A��	�	�A��
��t�t��q�T�F�B���W�}�}�g�}�'�'�"�+�+�}��
�r�2�h�'�'�'�'��t�t���	�r������		$�!�
$�
$���B���=�=��w�r�{�{�$�#�t�t�$��5�[�[��!�u�v�~�~�#�t�t��3�w��b��e�R��U�1�W�(=�(=�>�>�?�?�$�#�t�t�����4rc��|���\}}|tkrt}|dkr!|�tdd||g��dSg}d}g}|tzr
|t
zs&t
||��\}}}|st||��}|j}	|	t��t|��}
|	d��d}|rt}|�|r
|tz}n|r
|tz}|	|��|tkr|	|��n|	t��|dt�}|	|��|rl|	t|����|�t|��}|	|��|�|��|�t|����n%|r#t|��\}}t|||��t|��|
z
||
<dS)Nr�)r9r:rh�INFOrrr�r�rr�SRE_INFO_PREFIX�SRE_INFO_LITERAL�SRE_INFO_CHARSETr�r*r-)
rKrLr
rXr_r�r�r[r�rMrY�maskr\s
             r�
_compile_infor��s���
�
�
�
�F�B��	�G�|�|�
��	�Q�w�w����T�1�a��R�(�)�)�)���
�F��K��G��'�'�:�E�O�,C�:�':�7�E�'J�'J�$���W��	:�)�'�5�9�9�G��;�D��D��J�J�J��t�9�9�D�d�d�1�g�g�g��D�
�'�����7���*�*�D��	�'��&�&���D��J�J�J�	�G�|�|���R�������W�
�
�
�����!���D��H�H�H�
�/���S��[�[�������v�;�;�K���[�������F�������+�F�3�3�4�4�4�4�	�/�-�g�6�6������%��.�.�.��T���T�!�D��J�J�Jrc�:�t|ttf��Sr)�
isinstance�strrt)�objs r�isstringr�:s���c�C��<�(�(�(rc��|jj|z}g}t|||��t||j|��|�t��|Sr)�stater
r�r4r}rr5)r^r
rKs   r�_coder�=sV��
�G�M�E�!�E�
�D��$��5�!�!�!�
�T�1�6�5�!�!�!��K�K������Krc�F�dd�d�|D����zS)N�[%s]�, c3�DK�|]}dtjdzdz|fzV��dS)z%#0*xrN)r�CODESIZE�r��xs  r�	<genexpr>z_hex_code.<locals>.<genexpr>Ms7����M�M�1�g���q���):�A�(>�>�M�M�M�M�M�Mr)�join)rKs r�	_hex_coder�Ls(���D�I�I�M�M��M�M�M�M�M�M�Mrc���������ddl�t���d�ttt���dz
�����������fd���dt�����dS)Nrrc�����dd�����fd�
}��fd�}�dz
��}||k�rB|��|}|dz
}t|}|ttttt
ttfvr
||���n�|ttttttttfvr-�|}|dz
}||d|t!|��fz���n�|t"ur=�|}|dz
}t%t&|��}|||dd����n=|t(ur=�|}|dz
}t%t*|��}|||dd����n�|t,t.t0t2fvr2�|}|||||z����|dz||z��||z
}�n�|t4t6fvrD�||dz�\}}	|dz
}||d	||	t!|��t!|	��fz���nU|t8ur;||t;�||d
t<zz�����|d
t<zz
}�n|t>urȉ|}|dz
}tAd�!�fd��||d
tDj#zz�D������}
||||
��|d
tDj#zz
}�dz
�tI|��D]:}|t;�||d
t<zz�����|d
t<zz
}�;�dz��n@|tJtLtNtPtRfvr�|}|dz
}|||���n|tTur �|}|||||z���|dz
}�n�|tVuri�|}|||||z���|rG�|dz||z��||z
}|��|}|r|d
|||z���n|t��|�G|dz
}�nh|tXtZt\t^t`fvrJ�||dz�\}}}
|
tbkrd}
|||||
||z����|dz||z��||z
}�n�|tdur)�||dz�\}}||||||z���|dz
}�n�|tfthfvr;�||dz�\}}||||||z����|dz||z��||z
}�n|tjur2�|}|||||z����|dz||z��||z
}�nD|tlu�r+�||dz�\}}}}
|
tbkrd}
|||to|��||
||z���|dz�|tpzr��|dz|dz�\}}|d|��|dz����|z�}|ddd�!d�|D����zdd�!tst |����z���|z
�|d���|z����|z
�|ttzr$�dz
�|d����||z���dz�||z
}ntw|���||k��B�dz�dS)N)�toc���|���|��|d|fzfz
}td����vrdndfzd�dz
z���t|�dS)Nz(to %d)z%*d%s �:�.z  r��end)�add�print)r��args�labels�level�offset_width�starts  ����r�print_z!dis.<locals>.dis_.<locals>.print_Wst����~��
�
�2������b�U�*�,�,���(�l�E�%�6�/�/�3�3�s�S�S��E�!�G�n�
&�
&�
&�
&��4�L�L�L�Lrc�L��td�d�zzz���t|�dS)N� rr�)r�)r�r�r�s ��r�print_2z"dis.<locals>.dis_.<locals>.print_2_s/����c�<�!�E�'�1�2�3�3�3�3��4�L�L�L�Lrrz
%#02x (%r)��	rz%#02x %#02x (%r-%r)rkrc3�b�K�|])}|�tj�j��V��*dSr)�to_bytesrr��	byteorder)r�r��syss  �rr�z$dis.<locals>.dis_.<locals>.<genexpr>�sQ�����(R�(R�,-�)*�
�
�4�=�#�-�(P�(P�(R�(R�(R�(R�(R�(Rr�branch�	MAXREPEATr��z
  prefix_skipz  prefixr�r�c3� K�|]	}d|zV��
dS)z%#02xNr	r�s  rr�z$dis.<locals>.dis_.<locals>.<genexpr>�s&����.K�.K�q�w��{�.K�.K�.K�.K�.K�.Krz(%r)�z	  overlap�in)<�OPCODESr5r(r.r0�	MAX_UNTIL�	MIN_UNTILr&r'r%�LITERAL_IGNORE�NOT_LITERAL_IGNORE�LITERAL_UNI_IGNORE�NOT_LITERAL_UNI_IGNORE�LITERAL_LOC_IGNORE�NOT_LITERAL_LOC_IGNORE�chrr;r��ATCODESrC�CHCODESr)r,r$r+rerfrgr�r�ri�listr�rr�rnr7rFrHrIrGrBrA�REPEAT�
REPEAT_ONE�MIN_REPEAT_ONE�POSSESSIVE_REPEAT�POSSESSIVE_REPEAT_ONEr�rJ�ASSERT�
ASSERT_NOTr8r��binr�ror��
ValueError)r�r�r�r�rzrV�argrYrXr_r�j�min�maxr
�
prefix_lenr�r�rK�dis_r�r�r�r�s`                 ������rr�zdis.<locals>.dis_Vs;����!�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�
	��
�����#�g�g��E��a��B�
��F�A����B��g�w��W���F�4�4�4���r�
�
�
�
����&�(:�*�,B�*�,B�D�D�D��1�g���Q�����r�<�3��C���/�9�:�:�:�:��r����1�g���Q����'�#�,�'�'����r�3�q�r�r�7�#�#�#�#��x����1�g���Q����'�#�,�'�'����r�3�q�r�r�7�#�#�#�#���I�}�m�D�D�D��A�w����r�4�A�d�F�+�+�+�+���Q�q�S�!�D�&�!�!�!��T�	�����/�0�0�0��a��1��f����B��Q�����r�0�B��C��G�G�S��W�W�3M�M�N�N�N�N��w�����r�9�T�!�Q��i��-?�*?�%@�A�A�B�B�B��S�)�^�#����z�!�!��1�g���Q����s�x�x�(R�(R�(R�(R�15�a��S�$�-�=O�9O�6O�1P�(R�(R�(R� R� R�S�S����r�3��(�(�(��S�$�-�'�'����
���s���(�(�A��G�I�d�1�a�#�y�.�.@�+@�&A�B�B�C�C�C���i��'�A�A���
�����h��9L�+�-�-�-��1�g���Q�����r�3������t����A�w����r�4�A�d�F�+�+�+�+��Q�����v����A�w����r�4�A�d�F�+�+�+�+��(��D��1��a��f�%�%�%���I�A��E���7�D��(���x��!�D�&�9�9�9�9�9���w�����(��Q������
�N�)�+@�B�B�B�!%�a��1��f����c�3��)�#�#�%�C���r�4��c�a��f�5�5�5�5���Q�q�S�!�D�&�!�!�!��T�	�����&�&� ��A�a�C��L�	��T���r�3���4��0�0�0�0��Q������
�+�+�+� ��A�a�C��L�	��c���r�4���4��0�0�0�0���Q�q�S�!�D�&�!�!�!��T�	����|�#�#��A�w����r�4�A�d�F�+�+�+�+���Q�q�S�!�D�&�!�!�!��T�	����t���(,�Q��!��V��%��e�S�#��)�#�#�%�C���r�4��U���S�#�!�D�&�A�A�A�A��!����?�*�
(�.2�1�Q�3��!��8�n�+�J���G�O�[�9�9�9���E�E�!�%��z�)9�"9�:�F��G�J�"�T�Y�Y�.K�.K�F�.K�.K�.K�%K�%K�K�"�R�W�W�S��f�-=�-=�%>�%>�>�@�@�@��Z�'�E��G�K��e�U�:�5E�.E�)F�G�G�G��Z�'�E��+�+���Q�J�E��G�D�M�M�M��D���$��'�'�'��Q�J�E��T�	��� ��n�n�$�o�#�g�g�r	��
���r)r��setrr�)rKr�r�r�r�r�s`@@@@@r�disr�Os����������J�J�J�
�U�U�F�
�E��s�3�t�9�9�q�=�)�)�*�*�L�I�I�I�I�I�I�I�I�I�I�V	�D��C��I�I�����rc
��t|��r|}tj||��}nd}t||��}|tzrt��t
|��|jj}dg|jj	z}|�
��D]
\}}|||<�tj|||jj
z||jj	dz
|t|����S)Nr)r�r�parser��SRE_FLAG_DEBUGr�r�r��	groupdict�groups�itemsr�compiler
�tuple)r^r
rLrK�
groupindex�
indexgrouprZrzs        rrr�s�����{�{�����M�!�U�#�#�������E�?�?�D��~���
�����D�	�	�	���"�J���!�'�.�(�J�� � �"�"�����1��
�1�
�
��<������&��	���q���E�*�%�%�
�
�
r)NNN)r)3rr�r�
_constants�_casefixrr'r%rr5r(rr�r�rr.r)r��
MIN_REPEATr�r�r��
MAX_REPEATr�r�r�r�rr
rr4r-r*r�r�r:r��intrsrur3r�r�r�r�r�r�r�r�r�rr	rr�<module>rs��&���������������"�"�"�"�"�"��;�'���7�#����$�
���R�y�(�����N�3����J�/��)�7�4I�J���&�0�,�,�,�,�qI�qI�qI�f���6J�J�J�J�X
�M�A��	��	�>�Q�
����(�s�3�3�3�3�
���������*"�"�"�&�&�&�>*�*�*�X9"�9"�9"�v)�)�)�
�
�
�N�N�N�R�R�R�j
�
�
�
�
�
rPKV*]z~�����)__pycache__/_parser.cpython-311.opt-1.pycnu�[����

o{������dZddlTdZdZed��Zed��Zed��Zed��Zed	��Z	ee
eeh��Z
eeeeeeeh��Zeed
��feed��feed��feed
��feed��feed��feed��feed��fd�Zeefeefeefeeefgfeeefgfeeefgfeeefgfeeefgfeee fgfee!fd�
Z"e#e$e%e&e'e(e)e*d�Z+e(e$ze*zZ,e-e)zZ.dZ/Gd�d��Z0Gd�d��Z1Gd�d��Z2d�Z3d�Z4d�Z5d�Z6d)d!�Z7d"�Z8d#�Z9d*d&�Z:d'�Z;d(�Z<d%S)+zInternal support module for sre�)�*z.\[{()*+?^$|z*+?{�
0123456789�01234567�0123456789abcdefABCDEF�4abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZz 	

����
�
�	��\)z\a�\bz\fz\nz\rz\tz\vz\\)
z\Arz\Bz\dz\Dz\sz\Sz\wz\Wz\Z)�i�L�m�s�x�a�t�ulc�D�eZdZd�Zed���Zdd�Zd�Zd�Zd�Z	dS)	�Statec�N�d|_i|_dg|_d|_i|_dS)N�)�flags�	groupdict�groupwidths�lookbehindgroups�grouprefpos��selfs �5/opt/alt/python-internal/lib/python3.11/re/_parser.py�__init__zState.__init__Ms0����
���� �6��� $��������c�*�t|j��S�N)�lenrr"s r$�groupszState.groupsSs���4�#�$�$�$r&Nc��|j}|j�d��|jtkrt	d���|�<|j�|d��}|�t	d|||fz���||j|<|S)Nztoo many groupsz7redefinition of group name %r as group %d; was group %d)r*r�append�	MAXGROUPS�errorr�get)r#�name�gid�ogids    r$�	opengroupzState.opengroupVs����k�������%�%�%��;��"�"��)�*�*�*����>�%�%�d�D�1�1�D����+�.2�C�$�-?�@�A�A�A�#&�D�N�4� ��
r&c�>�|���|j|<dSr()�getwidthr)r#r1�ps   r$�
closegroupzState.closegroupbs�� !�
�
��������r&c�6�||jko|j|duSr()r*r)r#r1s  r$�
checkgroupzState.checkgroupds!���T�[� �F�T�%5�c�%:�$�%F�Fr&c��|j�J|�|��s|�d���||jkr|�d���dSdS)N�cannot refer to an open groupz?cannot refer to group defined in the same lookbehind subpattern)r r9r.)r#r1�sources   r$�checklookbehindgroupzState.checklookbehindgroupgsl��� �,��?�?�3�'�'�
D��l�l�#B�C�C�C��d�+�+�+��l�l�$;�<�<�<�	-�,�,�+r&r()
�__name__�
__module__�__qualname__r%�propertyr*r3r7r9r=�r&r$rrKs�����������%�%��X�%�����-�-�-�G�G�G�<�<�<�<�<r&rc�N�eZdZd
d�Zdd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�ZdS)�
SubPatternNc�8�||_|�g}||_d|_dSr()�state�data�width)r#rFrGs   r$r%zSubPattern.__init__qs%����
��<��D���	���
�
�
r&rc�`�ttf}|jD�]\}}t|dzt	|��zd���|t
ur=t��|D]+\}}t|dzdzt	|��z|���,�p|turYt��t|d��D]4\}}|rt|dzdz��|�|dz���5��|tur_|\}}}	td|��|�|dz��|	r-t|dzdz��|	�|dz����:t|t��r(t��|�|dz����wt||��rd}
|D]h}t|t��r+|
st��|�|dz��d}
�B|
std	d���t|d���d}
�i|
st����td|����dS)
Nz  �)�endr�OR�ELSEFT� )�tuple�listrG�print�str�IN�BRANCH�	enumerate�dump�GROUPREF_EXISTS�
isinstancerD)r#�level�seqtypes�op�avrr�	condgroup�item_yes�item_no�nls           r$rVzSubPattern.dumpxsi���4�=���i�'	�'	�F�B���%��*�s�2�w�w�&�B�/�/�/�/��R�x�x������7�7�E�B���5��7�D�.�3�r�7�7�2�A�6�6�6�6�7��v�������%�b��e�,�,�$�$�D�A�q��1��e�D�j�4�/�0�0�0��F�F�5��7�O�O�O�O�$���&�&�/1�,�	�8�W��b�)�$�$�$��
�
�e�A�g�&�&�&��*��%��*�v�-�.�.�.��L�L��q��)�)�)���B�
�+�+�
���������a�� � � � ��B��)�)�
����
#�
#�A�!�!�Z�0�0�	#�!�$�!�G�G�G����u�Q�w����!���!�/�!�#�2�.�.�.�.��a�R�(�(�(�(�"������G�G�G���b�"�
�
�
�
�O'	�'	r&c�*�t|j��Sr()�reprrGr"s r$�__repr__zSubPattern.__repr__�s���D�I���r&c�*�t|j��Sr()r)rGr"s r$�__len__zSubPattern.__len__�s���4�9�~�~�r&c��|j|=dSr(�rG�r#�indexs  r$�__delitem__zSubPattern.__delitem__�s���I�e���r&c��t|t��r t|j|j|��S|j|Sr()rX�slicerDrFrGrhs  r$�__getitem__zSubPattern.__getitem__�s:���e�U�#�#�	<��d�j�$�)�E�*:�;�;�;��y���r&c��||j|<dSr(rg�r#ri�codes   r$�__setitem__zSubPattern.__setitem__�s����	�%���r&c�<�|j�||��dSr()rG�insertros   r$rszSubPattern.insert�s ���	�����%�%�%�%�%r&c�:�|j�|��dSr()rGr,)r#rps  r$r,zSubPattern.append�s���	��������r&c�n�|j�|jSdx}}|jD�]�\}}|turVt}d}|dD]9}|���\}}t||��}t
||��}�:||z}||z}�e|tur"|���\}}||z}||z}��|tur(|d���\}}||z}||z}��|tvrW|d���\}}|||dzz}|dtkr|r	t}��|||dzz}��!|tvr|dz}|dz}��6|tur!|j
j|\}}||z}||z}��`|turq|d���\}}|d�>|d���\}}t||��}t
||��}nd}||z}||z}���|t urn���t|t��t|t��f|_|jS)Nrr����)rHrGrT�MAXWIDTHr5�min�max�ATOMIC_GROUP�
SUBPATTERN�_REPEATCODES�	MAXREPEAT�
_UNITCODES�GROUPREFrFrrW�SUCCESS)	r#�lo�hir[r\r�j�l�hs	         r$r5zSubPattern.getwidth�s`���:�!��:�����R��i�+	�+	�F�B���V�|�|������Q�%�"�"�B��;�;�=�=�D�A�q��A�q�	�	�A��A�q�	�	�A�A��!�V���!�V����|�#�#��{�{�}�}���1��!�V���!�V����z�!�!��"�v���(�(���1��!�V���!�V����|�#�#��!�u�~�~�'�'���1��!�b��e�)�^���a�5�I�%�%�!�%�!�B�B��a�"�Q�%�i��B�B��z�!�!��!�V���!�V����x����z�-�b�1���1��!�V���!�V�����&�&��!�u�~�~�'�'���1��a�5�$��a�5�>�>�+�+�D�A�q��A�q�	�	�A��A�q�	�	�A�A��A��!�V���!�V����w��������X�&�&��B��(9�(9�9��
��z�r&r(�r)
r>r?r@r%rVrcrerjrmrqrsr,r5rBr&r$rDrDos�����������)�)�)�)�T��������� � � � � � �&�&�&����2�2�2�2�2r&rDc�b�eZdZd�Zd�Zd�Zd�Zd�Zd�Ze	d���Z
d�Zd	�Zdd�Z
d�Zd
S)�	Tokenizerc���t|t��|_||_|jst|d��}||_d|_d|_|���dS)N�latin1r)rXrR�istext�string�decoded_stringri�next�_Tokenizer__next)r#r�s  r$r%zTokenizer.__init__�sZ�� ���-�-�������{�	+����*�*�F�$�����
���	����
�
�
�
�
r&c�2�|j}	|j|}n#t$rd|_YdSwxYw|dkrQ|dz
}	||j|z
}n:#t$r-t	d|jt
|j��dz
��d�wxYw|dz|_||_dS)Nrrzbad escape (end of pattern))rir��
IndexErrorr�r.r�r))r#ri�chars   r$�__nextzTokenizer.__next�s����
��	��&�u�-�D�D���	�	�	��D�I��F�F�	�����4�<�<��Q�J�E�
I���+�E�2�2�����
I�
I�
I��9� �K��T�[�)9�)9�A�)=�?�?�DH�I�
I�����Q�Y��
���	�	�	s�
�,�,�A�7Bc�H�||jkr|���dSdS)NTF�r�r�)r#r�s  r$�matchzTokenizer.matchs&���4�9����K�K�M�M�M��4��ur&c�<�|j}|���|Sr(r�)r#�thiss  r$r/z
Tokenizer.gets���y�����
�
�
��r&c�z�d}t|��D](}|j}||vrn||z
}|����)|S�NrJ)�ranger�r�)r#�n�charset�result�_�cs      r$�getwhilezTokenizer.getwhile	sP�����q���	�	�A��	�A��������a�K�F��K�K�M�M�M�M��
r&c��d}	|j}|���|�@|s|�d|z���|�d|zt|�����||kr|s|�d|zd���n||z
}��|S)NrJTzmissing zmissing %s, unterminated namer)r�r�r.r))r#�
terminatorr0r�r�s     r$�getuntilzTokenizer.getuntils�����	��	�A��K�K�M�M�M��y��8��*�*�Z�$�%6�7�7�7��j�j�!@�:�!M�!$�V���.�.�.��J����;��*�*�Z�$�%6��:�:�:���a�K�F�	��
r&c�>�|jt|jpd��z
Sr��rir)r�r"s r$�posz
Tokenizer.pos"s���z�C��	��R�0�0�0�0r&c�>�|jt|jpd��z
Sr�r�r"s r$�tellzTokenizer.tell%s���z�C��	��R�0�0�0�0r&c�<�||_|���dSr()rir�rhs  r$�seekzTokenizer.seek's����
����
�
�
�
�
r&rc��|js)|�dd���d��}t||j|���|z
��S)N�ascii�backslashreplace)r��encode�decoder.r�r�)r#�msg�offsets   r$r.zTokenizer.error+sP���{�	J��*�*�W�&8�9�9�@�@��I�I�C��S�$�+�t�y�y�{�{�V�';�<�<�<r&c�^�|���s+d|z}|�|t|��|z���|jsd|���sRddl}|�d||���t|��z
|z
fzt|dz���dSdSdS)N�bad character in group name %rrz-bad character in group name %a at position %d���
stacklevel)	�isidentifierr.r)r��isascii�warnings�warnr��DeprecationWarning)r#r0r��nestedr�r�s      r$�checkgroupnamezTokenizer.checkgroupname0s���� � �"�"�	6�2�T�9�C��*�*�S�#�d�)�)�f�"4�5�5�5���	�t�|�|�~�~�	��O�O�O��M�M�?��t�y�y�{�{�S��Y�Y�.��7�8�9�"�v��z�
�
�
�
�
�
�	�	�	�	r&Nr�)r>r?r@r%r�r�r/r�r�rAr�r�r�r.r�rBr&r$r�r��s������������� ���
��������� �1�1��X�1�1�1�1����=�=�=�=�

�
�
�
�
r&r�c��t�|��}|r|St�|��}|r|dtur|S	|dd�}|dkrv||�dt
��z
}t
|��dkr&|�d|zt
|�����tt|dd�d��fS|dkr}|j
rv||�dt
��z
}t
|��d	kr&|�d|zt
|�����tt|dd�d��fS|d
kr�|j
r�||�dt
��z
}t
|��dkr&|�d|zt
|�����t|dd�d��}t|��t|fS|d
kr�|j
r�ddl}|�
d��s|�d���|�dd��}	t|�|����}nL#t"t$f$r8|�d|zt
|��t
d��z��d�wxYwt|fS|t&vrk||�dt&��z
}t|dd�d��}|dkr&|�d|zt
|�����t|fS|t(vrt*�t
|��dkrK|t,vr&|�d|zt
|�����tt|d��fSn#t*$rYnwxYw|�d|zt
|�����)Nrrrwr��incomplete escape %s�r��U��
�N�{�	missing {�}�character name�undefined character name %r�\N{}��.octal escape value %s outside of range 0-0o377�
bad escape %s)�ESCAPESr/�
CATEGORIESrSr��	HEXDIGITSr)r.�LITERAL�intr��chr�unicodedatar�r��ord�lookup�KeyError�	TypeError�	OCTDIGITS�DIGITS�
ValueError�ASCIILETTERS)r<�escaperpr�r��charnames      r$�
_class_escaper�<s����;�;�v���D������>�>�&�!�!�D����Q��2�
�
���1
��1�Q�3�K����8�8��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�b� � ��l�l�#9�F�#B�C��K�K�P�P�P��F�1�2�2�J��#�#�A���F�F�F��A�:��
�#�X�X�&�-�X������<�<��$�$�
0��l�l�;�/�/�/����s�,<�=�=�H�
K���*�*�8�4�4�5�5�����i�(�
K�
K�
K��l�l�#@�8�#K�#&�x�=�=�3�w�<�<�#?�A�A�FJ�K�
K�����A�:��
�)�^�^��f�o�o�a��3�3�3�F��F�1�2�2�J��"�"�A��5�y�y��l�l�$3�5;�$<�=@��[�[�J�J�J��A�:��
�&�[�[����v�;�;�!����L� � ��l�l�?�V�#;�S��[�[�I�I�I��C��q�	�N�N�*�*����
�
�
���
����
�,�,���/��V���
=�
=�=sO�
BN�BN�BN�*AN�<"I�N�A	J(�(N�4A3N�(A-N�
N$�#N$c�	�t�|��}|r|St�|��}|r|S	|dd�}|dkrv||�dt��z
}t|��dkr&|�d|zt|�����tt|dd�d��fS|dkr}|j	rv||�dt��z
}t|��dkr&|�d|zt|�����tt|dd�d��fS|d	kr�|j	r�||�d
t��z
}t|��dkr&|�d|zt|�����t|dd�d��}t|��t|fS|dkr�|j	r�d
dl}|�d��s|�d���|�
dd��}	t|�|����}nL#t t"f$r8|�d|zt|��td��z��d�wxYwt|fS|dkr=||�dt$��z
}tt|dd�d
��fS|t&v�rW|jt&vr�||���z
}|dt$vr�|dt$vrr|jt$vrd||���z
}t|dd�d
��}|dkr&|�d|zt|�����t|fSt|dd���}||jkrW|�|��s#|�dt|�����|�||��t0|fS|�d|zt|��dz
���t|��dkrK|t2vr&|�d|zt|�����tt|d��fSn#t4$rYnwxYw|�d|zt|�����)Nrrwrr�r�r�rr�r�r�r�r�rr�r�r�r�r�r��0r�r�r;�invalid group reference %dr�)r�r/r�r�r�r)r.r�r�r�r�r�r�r�r�r�r�r�r�r�r�r*r9r=r�r�r�)r<r�rFrpr�r�r��groups        r$�_escaper�xs����>�>�&�!�!�D������;�;�v���D�����B
��1�Q�3�K����8�8��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�b� � ��l�l�#9�F�#B�C��K�K�P�P�P��F�1�2�2�J��#�#�A���F�F�F��A�:��
�#�X�X�&�-�X������<�<��$�$�
0��l�l�;�/�/�/����s�,<�=�=�H�
K���*�*�8�4�4�5�5�����i�(�
K�
K�
K��l�l�#@�8�#K�#&�x�=�=�3�w�<�<�#?�A�A�FJ�K�
K�����A�:��
�#�X�X��f�o�o�a��3�3�3�F��C��q�r�r�
�A�.�.�.�.�
�&�[�[��{�f�$�$��&�*�*�,�,�&���1�I��*�*�v�a�y�I�/E�/E��K�9�,�,��f�j�j�l�l�*�F��F�1�2�2�J��*�*�A��5�y�y�$�l�l�,;�=C�,D�+.�v�;�;�8�8�8�#�A�:�%���q�r�r�
�O�O�E��u�|�#�#��'�'��.�.�4� �,�,�'F�'*�6�{�{�4�4�4��*�*�5�&�9�9�9����&��,�,�;�e�C�S��[�[�ST�_�U�U�U��v�;�;�!����L� � ��l�l�?�V�#;�S��[�[�I�I�I��C��q�	�N�N�*�*����
�
�
���
����
�,�,���/��V���
=�
=�=s\�BR(�BR(�BR(�AR(�-"I�R(�A	J�R(�%AR(�(B>R(�'A8R(� BR(�(
R5�4R5c�P�tt�|����Sr()rP�dict�fromkeys)�itemss r$�_uniqr��s����
�
�e�$�$�%�%�%r&c	�:�g}|j}|j}|���}	|t||||dz|o|����|d��sn|s|jt
z}�At
|��dkr|dSt|��}	d}	|D]}
|
sn8|	�	|
d}	�|
d|	krn� |D]}
|
d=�|�|	���C	g}|D]x}
t
|
��dkrn�|
d\}}
|tur|�||
f���C|tur+|
ddtur|�|
���wn+|�tt|��f��|S|�td|ff��|S)NTr�|r)r,r�r��_parser�SRE_FLAG_VERBOSEr)rDr�rS�NEGATE�extendr�rT)r<rF�verboser�r��itemsappend�sourcematch�start�
subpattern�prefix�item�setr[r\s              r$�
_parse_subr��s��
�E��,�K��,�K��K�K�M�M�E�5���F�6�5�'�6�A�:�%�:�3�e�)�5�5�	6�	6�	6��{�3���	���	5��k�$4�4�G�
5��5�z�z�Q����Q�x���E�"�"�J�����
	�
	�D��
����~��a�����a��F�"�"���#�
�
�
����G�G����f�%�%�%��
�
�C������t�9�9��>�>��E��a����B�
��=�=��J�J��B�x� � � � �
�2�X�X�"�Q�%��(�&�0�0��J�J�r�N�N�N�N��E�	���2�u�S�z�z�*�+�+�+������v��e�}�-�.�.�.��r&Fc���t|��}|j}|j}|j}t}	t
}
	|j}|��nZ|dvr�nT|��|r&|tvr�(|dkr	|��}|�|dkrn��D|ddkrt|||��}||���n�|tvr|t|
|��f���n�|dk�r�|���dz
}
g}|j}|jdkr9ddl}|�
d	|���zt|d
z���|d��}	|��}|�+|�d
|���|
z
���|dkr|r�n�|ddkrt!||��}ny|re|dvra|j|krVddl}|�
d|dkrdn|dkrdn	|dkrdnd|���dz
fzt|d
z���t|
|��f}|d���r�|��}|�+|�d
|���|
z
���|dkrE|dt"ur|dd}||��|t|
d��f���nd|ddkrt!||��}nT|dkr<ddl}|�
d|���dz
zt|d
z���t|
|��f}|dtks|dtkr>d|�d|��}|�|t	|��dzt	|��z���|d}|d}||kr>d|�d|��}|�|t	|��dzt	|��z���|t$||ff��n(|dt"ur|dd}||�����t'|��}|	|��dkrJ|ddtur5|r |t(|ddf���n;||d���n(|r|�dt,df��|t"|f���
n�|t.v�r�|���}
|dkrd\}}�n�|dkrdt0}}�n�|dkrdt0}}�ns|dk�rZ|jd kr|t|
|��f�����dt0}}d!x}}|jt2vr||��z
}|jt2v�|d"��r*|jt2vr||��z
}|jt2v�n|}|d ��s2|t|
|��f��|�|
�����|r)t7|��}|t0krt9d#���|rZt7|��}|t0krt9d#���||kr+|�d$|���|
z
���nt;d%|�����|r|d&d�}nd}|r|ddt<ur;|�d'|���|
z
t	|��z���|ddt>vr;|�d(|���|
z
t	|��z���|ddt@ur|dd\}}}}|�|s|s|}|d��rtB|||ff|d&<�n8|d��rtD|||ff|d&<�ntF|||ff|d&<�n|d)kr|tHdf���n�|d*k�r�|���dz
} d}!d+}"d}#d}d}|d���rf|��}|�|�d,���|d-k�rh|d.��r/|�%d/d0��}#|�&|#d|���n|d1��r�|�%d2d0��}#|�&|#d|��|j'�|#��}$|$�+d3|#z}|�|t	|#��dz���|�(|$��s&|�d4t	|#��dz���|�)|$|��|tT|$f�����|��}|�|�d,���|�d5|zt	|��dz���|d6krd+}!�n�|dkrE	|j�+|�d7|���| z
���|��d2krn�B�	��|d8vr�d}%|d.kre|��}|�|�d,���|d9vr)|�d:|zt	|��dz���d&}%|j+}&|&�|j,|_+t[||||dz��}|%dkr	|&�d|_+|d2��s+|�d;|���| z
���|d1kr|t\|%|ff��n|t^|%|ff���
��|d*k�r�|�%d2d0��}'|'�0��r`|�&|'d|��|j'�|'��}(|(�+d3|'z}|�|t	|'��dz����n�	t7|'��}(|(dkrtb�n:#tb$r-d<|'z}|�|t	|'��dz��d�wxYw|(s&|�d=t	|'��dz���|(tdkr+d>|(z}|�|t	|'��dz���|(|j3vr/|���t	|'��z
dz
|j3|(<|'�4��r|'�5��sqddl}|�
d?|j6rto|'��ntq|'��|���t	|'��z
dz
fztr|d
z���|�)|(|��tu||||dz��})|�d@��r6tu||||dz��}*|jd@kr|�dA���nd}*|�d2��s+|�d;|���| z
���|tv|(|)|*ff���
�o|d/krd+}!d}"n�|txvs|dkr[t{|||��}+|+�@|r|r+|�dB|���| z
���|j>t~z}�
��|+\}}d+}!n)|�dC|zt	|��dz���|!rU	|�@|#��}n@#t$r1},|�|,jAt	|#��dz��d�d},~,wwxYwd}|s
|t~zo
|t~z}-t[|||-|dz��}|�d2��s+|�d;|���| z
���|�|�B||��|"r|t�|f��ne|t@||||ff��nN|dkr|t<t�f��n0|dDkr|t<t�f��nt;dE|�������et�t	|����ddd&�D]-}.||.\}/}0|/t@ur|0\}}}}|�|s|s
|||.|.dz�<�.|S)FNTz|)�#rrr�[rz"Possible nested set at position %dr�r��^zunterminated character set�]z-&~|zPossible set %s at position %d�-�
difference�&�intersection�~zsymmetric difference�unionz&Possible set difference at position %drwzbad character range �?)rrr�+r�r�rJ�,z"the repetition number is too largez"min repeat greater than max repeatzunsupported quantifier rvznothing to repeatzmultiple repeat�.�(Fzunexpected end of pattern�P�<�>�
group name�=�)�unknown group name %rr;zunknown extension ?P�:zmissing ), unterminated commentz=!<z=!zunknown extension ?<z"missing ), unterminated subpatternr�zbad group numberr��-bad character in group name %s at position %dr�z/conditional backref with more than two branchesz/global flags not at the start of the expressionzunknown extension ?�$zunsupported special character )GrDr,r/r�r)r�r��
WHITESPACEr��
SPECIAL_CHARSr�r�r�r��
FutureWarningr.r�rS�RANGEr��NOT_LITERALrsr��REPEAT_CHARSr~r�r�r��
OverflowError�AssertionError�ATr}r|�
MIN_REPEAT�POSSESSIVE_REPEAT�
MAX_REPEAT�ANYr�r�rr9r=r�r r*r��ASSERT�
ASSERT_NOTr�r�r-r!�	isdecimalr�r�rbr�r�r�rW�FLAGS�_parse_flagsrr�r3r�r7r{�AT_BEGINNING�AT_ENDr�)1r<rFr�r��firstr��subpatternappend�	sourcegetr��_len�_ordr�rp�herer��	setappendr��negate�code1�that�code2r�r�r�ryrzr�r�r��	add_flags�	del_flagsr6r��capture�atomicr0r1�dirr �condnamer]r^r_r�err�sub_verboserr[r\s1                                                 r$r�r�s����E�"�"�J�"�(���
�I��,�K��D��D�lO��{���<���4�<�<���	�����		��z�!�!���s�{�{��$�9�;�;�D��|�t�t�|�|������7�d�?�?��6�4��/�/�D���T�"�"�"�"�
��
&�
&���g�t�t�D�z�z�2�3�3�3�3�
�S�[�[��;�;�=�=�1�$�D��C��
�I��{�c�!�!������
�
�8�6�;�;�=�=�H�!�f�q�j�����!�[��%�%�F�9
%� �y�{�{���<� �,�,�'C�'-�{�{�}�}�t�';�=�=�=��3�;�;�3�;���!�W��_�_�)�&�$�7�7�E�E��
�t�v�~�~�&�+��2E�2E�'���� �
�
�<�04������26�#�+�+���:>�#�+�+� 6� 6� '� &���
�
�� 1�@3�3�*�f�q�j�&����$�T�T�$�Z�Z�/�E��;�s�#�#�#%�$�9�;�;�D��|�$�l�l�+G�+1�;�;�=�=�4�+?�A�A�A��s�{�{� ��8�r�>�>�$)�!�H�Q�K�E�!�	�%�(�(�(�!�	�7�D�D��I�I�"6�7�7�7���A�w�$��� -�f�d� ;� ;����3�;�;�+�O�O�O�$�M�M� H�$*�K�K�M�M�A�$5�!7� -�&�1�*�*����
!(���d��� 3���Q�x�7�*�*�e�A�h�'�.A�.A��=A�T�T�4�4�H��$�l�l�3��D�	�	�A�
��D�	�	�0I�J�J�J��q��B��q��B��B�w�w�w�=A�T�T�4�4�H��$�l�l�3��D�	�	�A�
��D�	�	�0I�J�J�J��I�u�r�2�h�/�0�0�0�0��Q�x�2�~�~� %�a������I�e�$�$�$�s9
%�v��*�*�C��t�C�y�y�A�~�~�#�a�&��)�w�"6�"6��-�$�$�k�3�q�6�!�9�%=�>�>�>�>�$�$�S��V�,�,�,�,��2��J�J�q�6�4�.�1�1�1�!� �"�c��+�+�+�+�
�\�
!�
!��;�;�=�=�D��s�{�{����S�S������i�S��������i�S��������;�#�%�%�$�$�g�t�t�D�z�z�%:�;�;�;���i�S�����R��k�V�+�+��)�)�+�+�%�B��k�V�+�+��;�s�#�#�� �+��/�/��i�i�k�k�)��!�+��/�/���B�"�{�3�'�'��$�$�g�t�t�D�z�z�%:�;�;�;��K�K��%�%�%���R��b�'�'�C��i�'�'�+�,P�Q�Q�Q��A��b�'�'�C��i�'�'�+�,P�Q�Q�Q��S�y�y�$�l�l�+O�+1�;�;�=�=�4�+?�A�A�A��%�n�D�D�%J�K�K�K��
�!�"�#�#�������
E�4��7�1�:��+�+��l�l�#6�#)�;�;�=�=�4�#7�#�d�)�)�#C�E�E�E��A�w�q�z�\�)�)��l�l�#4�#)�;�;�=�=�4�#7�#�d�)�)�#C�E�E�E��A�w�q�z�Z�'�'�15�a����.��y�)�Q��=��=�9�=��D��{�3���
@�",�s�C��.>�!?�
�2�����S�!�!�
@�"3�c�3��5E�!F�
�2���#-�s�C��.>�!?�
�2���
�S�[�[���c�4�[�)�)�)�)�
�S�[�[��K�K�M�M�A�%�E��G��F��D��I��I��{�3���L
6� �y�{�{���<� �,�,�'B�C�C�C��3�;�;�"�{�3�'�'�:�%���s�L�A�A���-�-�d�A�v�>�>�>�>�$��S�)�)�:�%���s�L�A�A���-�-�d�A�v�>�>�>�#�o�1�1�$�7�7���;�"9�D�"@�C�"(�,�,�s�C��I�I��M�"B�"B�B�$�/�/��4�4�>�"(�,�,�/N�/2�4�y�y�1�}�#>�#>�>��2�2�3��?�?�?�(�(�(�C��9�9�9� � )�y�{�{���<�"(�,�,�/J�"K�"K�K�$�l�l�+A�D�+H�+.�t�9�9�q�=�:�:�:��S�[�[�#�G�G��S�[�[�"�!�;�.�"(�,�,�/P�/5�{�{�}�}�u�/D�#F�#F�F�$�9�;�;�#�-�-�!�"���U�]�]��C��s�{�{�(�y�{�{���<�"(�,�,�/J�"K�"K�K��t�+�+�"(�,�,�/E��/L�/2�4�y�y�1�}�#>�#>�>� ��+0�+A�(�+�3�5:�\�E�2�"�6�5�'�6�A�:�F�F�A��Q�w�w�+�3�59�E�2�&�;�s�+�+�B�$�l�l�+O�+1�;�;�=�=�5�+@�B�B�B��s�{�{�(�(�&�3��(�);�<�<�<�<�(�(�*�s�A�h�)?�@�@�@���S�[�[�%���s�L�A�A�H��,�,�.�.���-�-�h��6�B�B�B�$)�O�$7�$7��$A�$A�	�$�,�"9�H�"D�C�"(�,�,�s�C��M�M�A�4E�"F�"F�F�-�Q�(+�H�
�
�I�(�1�}�}�&0� 0� -��)�Q�Q�Q�"B�X�"M�C�"(�,�,�s�C��M�M�A�4E�"F�"F�D�P�Q���� )�B�"(�,�,�/A�/2�8�}�}�q�/@�#B�#B�B�$�	�1�1�">��"J�C�"(�,�,�s�C��M�M�A�4E�"F�"F�F�$�E�,=�=�=� &���
�
��H�
�
� =�� A�"�-�i�8�!)� 2� 2� 4� 4���9I�9I�9K�9K��+�O�O�O�$�M�M� O�39�=�!U��h����e�H�o�o�!'������X���!>��!B�!D�!D�!3�v��z�	*�����.�.�y�&�A�A�A�%�f�e�W�f�q�j�I�I�H��|�|�C�(�(�'�"(�����!��"L�"L��!�;�#�-�-�"(�,�,�/`�"a�"a�a�.�#'��!�<�<��,�,�B�$�l�l�+O�+1�;�;�=�=�5�+@�B�B�B�$�$�o�	�8�W�7U�%V�W�W�W���S�[�[�#�G�!�F�F��U�]�]�d�c�k�k�(����=�=�E��}�$�F�
�F�"(�,�,�0C�/5�{�{�}�}�u�/D�#F�#F�F�#(�+�0@�"@�� �+0�(�I�y�#�G�G� �,�,�'<�t�'C�'*�4�y�y�1�}�6�6�6��
�I�!�O�O�D�1�1�E�E���I�I�I� �,�,�s�w��D�	�	�A�
�>�>�D�H�����I������#�E�	�4D�(D�>� )�,<� <�=�
��6�5�+�v��z�B�B�A��<�<��$�$�
:��l�l�#G�#)�;�;�=�=�5�#8�:�:�:�� �� � ���*�*�*��
Q� � �,��!2�3�3�3�3� � �*�u�i��A�.N�!O�P�P�P�P�
�S�[�[���b�,�/�0�0�0�0�
�S�[�[���b�&�\�*�*�*�*�!�.�t�t�!M�N�N�N�YlO�^�3�z�?�?�
#�
#�D�D�b�D�
)�'�'���A����B�
����-/�*�E�9�i���}�Y�}�y�}�%&�
�1�a��c�6�"���s$�
m*�*7n!�y�
z�#,z�zc�
�|j}d}d}|dkr�	t|}|jr|dkrd}|�|���n|dkrd}|�|���||z}|tzr%|tz|krd}|�|���|��}|�|�d	���|d
vrnE|tvr;|���rdnd	}|�|t
|�������|dkr|xj|zc_dS|tzr|�d
d���|dk�r|��}|�|�d���|tvr;|���rdnd}|�|t
|�����	t|}|tzrd}|�|���||z}|��}|�|�d���|dkrnE|tvr;|���rdnd}|�|t
|�������|tzr|�dd���||zr|�dd���||fS)NrrTrz8bad inline flags: cannot use 'L' flag with a str patternrz:bad inline flags: cannot use 'u' flag with a bytes patternz9bad inline flags: flags 'a', 'u' and 'L' are incompatiblezmissing -, : or )z)-:zunknown flagrz,bad inline flags: cannot turn on global flagrzmissing flagz8bad inline flags: cannot turn off flags 'a', 'u' and 'L'z	missing :rz-bad inline flags: cannot turn off global flagz(bad inline flags: flag turned on and off)	r/r'r�r.�
TYPE_FLAGS�isalphar)r�GLOBAL_FLAGS)r<rFr�r-r6r7�flagr�s        r$r(r(�s����
�I��I��I��s�{�{�	3���;�D��}�
,��3�;�;�T�C� �,�,�s�+�+�+���3�;�;�V�C� �,�,�s�+�+�+����I��z�!�
(�	�J�(>�4�'G�'G�Q���l�l�3�'�'�'��9�;�;�D��|��l�l�#6�7�7�7��u�}�}���5� � �(,�����O�n�n�<O���l�l�3��D�	�	�2�2�2�+	3�,�s�{�{�
���y� ����t��<��N��l�l�I�1�M�M�M��s�{�{��y�{�{���<��,�,�~�.�.�.��u���$(�L�L�N�N�F�.�.��C��,�,�s�C��I�I�.�.�.�
	3���;�D��j� �
(�P���l�l�3�'�'�'����I��9�;�;�D��|��l�l�;�/�/�/��s�{�{���5� � �(,�����G�n�n�K���l�l�3��D�	�	�2�2�2�
	3��<��O��l�l�J�A�N�N�N��9��J��l�l�E�q�I�I�I��i��r&c�8�t|t��rH|tzrtd���|tzs|t
z}nV|t
zrtd���n<|t
zrtd���|tzr|tzrtd���|S)Nz)cannot use LOCALE flag with a str patternz(ASCII and UNICODE flags are incompatiblez,cannot use UNICODE flag with a bytes patternz'ASCII and LOCALE flags are incompatible)rXrR�SRE_FLAG_LOCALEr��SRE_FLAG_ASCII�SRE_FLAG_UNICODE)�srcrs  r$�	fix_flagsrH�s����#�s���H��?�"�	J��H�I�I�I��~�%�	I��%�%�E�E�
�%�
%�	I��G�H�H�H�	I��#�#�	M��K�L�L�L��?�"�	H�u�~�'=�	H��F�G�G�G��Lr&rNc���t|��}|�t��}||_||_t	|||t
zd��}t
||jj��|j_|j�|�	d���|jj
D]8}||jjkr&d|z}t|||jj
|����9|tzr|�
��|S)Nrzunbalanced parenthesisr�)r�rrrRr�r�rHrFr�r.r!r*�SRE_FLAG_DEBUGrV)rRrrFr<r6�gr�s       r$�parserL�s����s�^�^�F��}������E�K��E�I��6�5�%�*:�":�A�>�>�A��c�1�7�=�1�1�A�G�M�
�{���l�l�3�4�4�4�
�W�
 �:�:��������.��2�C���S�!�'�"5�a�"8�9�9�9��
�~���	�������Hr&c	����
���t|����j}g�g�g�
�
j}��
���fd�}�j}	|��}|��n�|ddk�r�|d}|dk�rՉ�d��s��d�����d	d
��}|���rC��|dd��	||}	�nA#t$rtd|z��d�wxYw	t|��}	|	dkrt�n8#t$r+��d
|zt|��dz��d�wxYw|	tkr)��d|	zt|��dz���|���r|���snddl}
|
�d�jrt)|��nt+|������t|��z
dz
fzt.d���||	t|��dz���n�|dkri�jt2vr(||��z
}�jt2vr
||��z
}|t5t|dd�d��dz�����nd|t6vr�d}�jt6vr�||��z
}|t2vr�|dt2vry�jt2vrk||��z
}d}t|dd�d��}|dkr&��d|zt|�����|t5|����|s1|t|dd���t|��dz
��ny	t5t8|d��}n@#t$r3|t:vr'��d|zt|����d�YnwxYw||��n||����ԉ
r(��d��
����t?|t@��sd��D�����fS)Nc� ��|�jkr��d|z|����r-��d�������dd�=��t	���|f����d��dS)Nr�rJ)r*r.r,�joinr))rir�r*�literal�literalsrrFs  �����r$�addgroupz parse_template.<locals>.addgroup�s�����5�<����'�'�6��>��D�D�D��	��O�O�B�G�G�G�,�,�-�-�-�����
��
�
�s�8�}�}�e�,�-�-�-���������r&TrrrrKrz	missing <rrrvrr�r�r�r�r�r�r�Frwr�r�rJc�@�g|]}|�dn|�d����S)Nzlatin-1)r�)�.0rs  r$�
<listcomp>z"parse_template.<locals>.<listcomp>Hs,��Q�Q�Q�1�A�I�D�D�1�8�8�I�+>�+>�Q�Q�Qr&)!r�r/r,�
groupindexr�r.r�r�r�r�r�r�r�r)r-r&r�r�r�r�rbr�r�r�r�r�r�r�r�r�rOrXrR)r<rF�sget�lappendrRrWr�r�r0rir��isoctalr*rPrQrs `          @@@@r$�parse_templater[�s��������	�&���A��5�D�
�F��H��G��n�G�����������!�J�B��t�v�v���<����7�d�?�?��Q��A��C�x�x��w�w�s�|�|�/��'�'�+�.�.�.��z�z�#�|�4�4���$�$�&�&���$�$�T�1�b�1�1�1�S� *�4� 0����#�S�S�S�(�)@�4�)G�H�H�d�R�S����?� #�D�	�	�� �1�9�9�",�,�%��%�?�?�?��g�g�&F��&M�&)�$�i�i�!�m�5�5�:>�?�?�����	�)�)��g�g�&B�U�&J�&)�$�i�i�!�m�5�5�5� �N�N�,�,��������'���� �
�
�K�+,�8�D�T�$�Z�Z�Z��t����V�V�X�X��D�	�	�1�A�5�7�7�/�1�	&��������D�	�	�A�
�.�.�.�.��c����6�Y�&�&��D�D�F�F�N�D��v��*�*�����������C��Q�R�R��!�,�,�t�3�4�4�5�5�5�5��f������6�V�#�#��D�D�F�F�N�D��Y���4��7�i�+?�+?���)�+�+��������"&����Q�R�R��!�,�,���u�9�9�"#�'�'�+:�<@�+A�BE�d�)�)�#M�#M�M����A�������;��H�S��a�b�b��]�]�C��I�I��M�:�:�:��S��w�t�}�Q�/�0�0�D�D���S�S�S��L�(�(��g�g�o��&<�c�$�i�i�H�H�d�R�)�(�S�������
�
�
�
��G�D�M�M�M�EB�F�*��������(�(�)�)�)��f�c�"�"�R�R�Q��Q�Q�Q���8��s*�C�C8�<D�5E� N5�5:O2�1O2c���|j}|jdd�}|\}}|dd�}	|D]\}}||��p|||<�n!#t$rtd|z��d�wxYw|�|��S)Nrr�)r�r�r�r.rO)�templater�rK�emptyr*rQrir�s        r$�expand_templater_Ks���
��A��L��!���E���F�H�����{�H�D�"�	0�	0�L�E�5��a��h�h�/�%�H�U�O�O�	0���D�D�D��0�5�8�9�9�t�C�D�����:�:�h���s�A�A)F)rN)=�__doc__�
_constantsrr�	frozensetr�r�r�r�rr r"r!r}r#rrSr�r�CATEGORYrr�r�r�AT_BEGINNING_STRING�AT_BOUNDARY�AT_NON_BOUNDARY�CATEGORY_DIGIT�CATEGORY_NOT_DIGIT�CATEGORY_SPACE�CATEGORY_NOT_SPACE�
CATEGORY_WORD�CATEGORY_NOT_WORD�
AT_END_STRINGr��SRE_FLAG_IGNORECASErD�SRE_FLAG_MULTILINE�SRE_FLAG_DOTALLr�rE�SRE_FLAG_TEMPLATErFr'r?rJrArxrrDr�r�r�r�r�r�r(rHrLr[r_rBr&r$�<module>rrsT��&�%������
���	��<�	 �	 ���I�j�!�!�	��I�.�/�/�	��y�O�P�P��
�Y�}�
%�
%�
��y�*�j�2C�D�E�E��
�Y��U�B���h�G�
H�
H�
�
�S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y��	�	��
�#�$������ ��(�N�+�,�-��(�.�/�0�1��(�N�+�,�-��(�.�/�0�1��(�M�*�+�,��(�-�.�/�0��
����
�
�	�	�	�	�	�	�	�	�	���o�
-�0@�
@�
�� 1�1����"<�"<�"<�"<�"<�"<�"<�"<�Hu�u�u�u�u�u�u�u�nT�T�T�T�T�T�T�T�l:>�:>�:>�xK>�K>�K>�Z&�&�&�:�:�:�xA�A�A�A�F: �: �: �x��� 
�
�
�
�6[�[�[�z
 �
 �
 �
 �
 r&PKV*]��_ΆK�K*__pycache__/__init__.cpython-311.opt-1.pycnu�[����

��0cL�s��V�dZddlZddlmZmZddlZgd�ZdZejej	ej
ej���Gd�d	������Zej
Z
d!d
�Zd!d�Zd!d�Zd"d
�Zd"d�Zd"d�Zd!d�Zd!d�Zd!d�Zd�Zd!d�Zd�dD��Zd�Zeejdd����Zeejdd���d����ZiZdZd�Z ej!e��d���Z"d�Z#d�Z$ddl%Z%d�Z&e%j'ee&e ��Gd�d ��Z(dS)#a�Support for regular expressions (RE).

This module provides regular expression matching operations similar to
those found in Perl.  It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range.

Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves.  You can
concatenate ordinary characters, so last matches the string 'last'.

The special characters are:
    "."      Matches any character except a newline.
    "^"      Matches the start of the string.
    "$"      Matches the end of the string or just before the newline at
             the end of the string.
    "*"      Matches 0 or more (greedy) repetitions of the preceding RE.
             Greedy means that it will match as many repetitions as possible.
    "+"      Matches 1 or more (greedy) repetitions of the preceding RE.
    "?"      Matches 0 or 1 (greedy) of the preceding RE.
    *?,+?,?? Non-greedy versions of the previous three special characters.
    {m,n}    Matches from m to n repetitions of the preceding RE.
    {m,n}?   Non-greedy version of the above.
    "\\"     Either escapes special characters or signals a special sequence.
    []       Indicates a set of characters.
             A "^" as the first character indicates a complementing set.
    "|"      A|B, creates an RE that will match either A or B.
    (...)    Matches the RE inside the parentheses.
             The contents can be retrieved or matched later in the string.
    (?aiLmsux) The letters set the corresponding flags defined below.
    (?:...)  Non-grouping version of regular parentheses.
    (?P<name>...) The substring matched by the group is accessible by name.
    (?P=name)     Matches the text matched earlier by the group named name.
    (?#...)  A comment; ignored.
    (?=...)  Matches if ... matches next, but doesn't consume the string.
    (?!...)  Matches if ... doesn't match next.
    (?<=...) Matches if preceded by ... (must be fixed length).
    (?<!...) Matches if not preceded by ... (must be fixed length).
    (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
                       the (optional) no pattern otherwise.

The special sequences consist of "\\" and a character from the list
below.  If the ordinary character is not on the list, then the
resulting RE will match the second character.
    \number  Matches the contents of the group of the same number.
    \A       Matches only at the start of the string.
    \Z       Matches only at the end of the string.
    \b       Matches the empty string, but only at the start or end of a word.
    \B       Matches the empty string, but not at the start or end of a word.
    \d       Matches any decimal digit; equivalent to the set [0-9] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode digits.
    \D       Matches any non-digit character; equivalent to [^\d].
    \s       Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
             bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the whole
             range of Unicode whitespace characters.
    \S       Matches any non-whitespace character; equivalent to [^\s].
    \w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
             in bytes patterns or string patterns with the ASCII flag.
             In string patterns without the ASCII flag, it will match the
             range of Unicode alphanumeric characters (letters plus digits
             plus underscore).
             With LOCALE, it will match the set [0-9_] plus characters defined
             as letters for the current locale.
    \W       Matches the complement of \w.
    \\       Matches a literal backslash.

This module exports the following functions:
    match     Match a regular expression pattern to the beginning of a string.
    fullmatch Match a regular expression pattern to all of a string.
    search    Search a string for the presence of a pattern.
    sub       Substitute occurrences of a pattern found in a string.
    subn      Same as sub, but also return the number of substitutions made.
    split     Split a string by the occurrences of a pattern.
    findall   Find all occurrences of a pattern in a string.
    finditer  Return an iterator yielding a Match object for each match.
    compile   Compile a pattern into a Pattern object.
    purge     Clear the regular expression cache.
    escape    Backslash all non-alphanumerics in a string.

Each function other than purge and escape can take an optional 'flags' argument
consisting of one or more of the following module constants, joined by "|".
A, L, and U are mutually exclusive.
    A  ASCII       For string patterns, make \w, \W, \b, \B, \d, \D
                   match the corresponding ASCII character categories
                   (rather than the whole Unicode categories, which is the
                   default).
                   For bytes patterns, this flag is the only available
                   behaviour and needn't be specified.
    I  IGNORECASE  Perform case-insensitive matching.
    L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.
    M  MULTILINE   "^" matches the beginning of lines (after a newline)
                   as well as the string.
                   "$" matches the end of lines (before a newline) as well
                   as the end of the string.
    S  DOTALL      "." matches any character at all, including the newline.
    X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
    U  UNICODE     For compatibility only. Ignored for string patterns (it
                   is the default), and forbidden for bytes patterns.

This module also defines an exception 'error'.

�N�)�	_compiler�_parser)�match�	fullmatch�search�sub�subn�split�findall�finditer�compile�purge�template�escape�error�Pattern�Match�A�I�L�M�S�X�U�ASCII�
IGNORECASE�LOCALE�	MULTILINE�DOTALL�VERBOSE�UNICODE�NOFLAG�	RegexFlagz2.2.1)�boundaryc���eZdZdZejxZZejxZ	Z
ejxZZ
ejxZZejxZZejxZZejxZZejxZZejZej Z e!Z"dS)r$rN)#�__name__�
__module__�__qualname__r#r�SRE_FLAG_ASCIIrr�SRE_FLAG_IGNORECASErr�SRE_FLAG_LOCALErr�SRE_FLAG_UNICODEr"r�SRE_FLAG_MULTILINErr�SRE_FLAG_DOTALLr r�SRE_FLAG_VERBOSEr!r�SRE_FLAG_TEMPLATE�TEMPLATE�T�SRE_FLAG_DEBUG�DEBUG�object�__str__�hex�_numeric_repr_���6/opt/alt/python-internal/lib/python3.11/re/__init__.pyr$r$�s��������F��(�(�E�A��2�2�J���*�*�F�Q��,�,�G�a��0�0�I���*�*�F�Q��,�,�G�a��.�.�H�q��$�E��n�G��N�N�Nr;r$c�H�t||���|��S)zqTry to apply the pattern at the start of the string, returning
    a Match object, or None if no match was found.)�_compiler��pattern�string�flagss   r<rr�s"���G�U�#�#�)�)�&�1�1�1r;c�H�t||���|��S)zkTry to apply the pattern to all of the string, returning
    a Match object, or None if no match was found.)r>rr?s   r<rr�s"���G�U�#�#�-�-�f�5�5�5r;c�H�t||���|��S)ztScan through string looking for a match to the pattern, returning
    a Match object, or None if no match was found.)r>rr?s   r<rr�s"���G�U�#�#�*�*�6�2�2�2r;c�L�t||���|||��S)aZReturn 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.)r>r	�r@�replrA�countrBs     r<r	r	�s&���G�U�#�#�'�'��f�e�<�<�<r;c�L�t||���|||��S)a�Return a 2-tuple containing (new_string, number).
    new_string is the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in the source
    string by the replacement repl.  number is the number of
    substitutions that were made. 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.)r>r
rFs     r<r
r
�s&���G�U�#�#�(�(��v�u�=�=�=r;c�J�t||���||��S)a�Split the source string by the occurrences of the pattern,
    returning a list containing the resulting substrings.  If
    capturing parentheses are used in pattern, then the text of all
    groups in the pattern are also returned as part of the resulting
    list.  If maxsplit is nonzero, at most maxsplit splits occur,
    and the remainder of the string is returned as the final element
    of the list.)r>r)r@rA�maxsplitrBs    r<rr�s$���G�U�#�#�)�)�&�(�;�;�;r;c�H�t||���|��S)aReturn a list of all non-overlapping matches in the string.

    If one or more capturing 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.)r>rr?s   r<rr�s"���G�U�#�#�+�+�F�3�3�3r;c�H�t||���|��S)z�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.)r>r
r?s   r<r
r
�s"��
�G�U�#�#�,�,�V�4�4�4r;c�"�t||��S)zACompile a regular expression pattern, returning a Pattern object.)r>)r@rBs  r<rr�s���G�U�#�#�#r;c�j�t���t���dS)z#Clear the regular expression cachesN)�_cache�clear�
_compile_repl�cache_clearr:r;r<rr�s'��
�L�L�N�N�N��������r;c��ddl}|�dt��|���5|�dt��t||tz��cddd��S#1swxYwYdS)zBCompile a template pattern, returning a Pattern object, deprecatedrNz�The re.template() function is deprecated as it is an undocumented function without an obvious purpose. Use re.compile() instead.�ignore)�warnings�warn�DeprecationWarning�catch_warnings�simplefilterr>r3)r@rBrVs   r<rr�s����O�O�O��M�M�.�%�	&�&�&�

�	 �	 �	"�	"�*�*����h�(:�;�;�;����q��)�)�*�*�*�*�*�*�*�*�*�*�*�*����*�*�*�*�*�*s�3A4�4A8�;A8c�4�i|]}|dt|��z��S)�\)�chr)�.0�is  r<�
<dictcomp>r`�s$��R�R�R�1�a���A����R�R�Rr;s()[]{}?*+-|^$\.&~# 	

c���t|t��r|�t��St|d��}|�t���d��S)z0
    Escape special characters in a string.
    �latin1)�
isinstance�str�	translate�_special_chars_map�encode)r@s r<rr�s^���'�3���F�� � �!3�4�4�4��g�x�(�(��� � �!3�4�4�;�;�H�E�E�Er;�ic��t|t��r|j}	tt	|��||fS#t
$rYnwxYwt|t��r|rtd���|Stj	|��std���|tzrddl}|�
dt��tj||��}|t zs}t#t��t$krF	tt't)t����=n#t*t,t
f$rYnwxYw|tt	|��||f<|S)Nz5cannot process flags argument with a compiled patternz1first argument must be string or compiled patternrzoThe re.TEMPLATE/re.T flag is deprecated as it is an undocumented flag without an obvious purpose. Don't use it.)rcr$�valuerP�type�KeyErrorr�
ValueErrorr�isstring�	TypeErrorr3rVrWrXrr5�len�	_MAXCACHE�next�iter�
StopIteration�RuntimeError)r@rBrV�ps    r<r>r>sz���%��#�#�����
��d�7�m�m�W�e�3�4�4���
�
�
���
�����'�7�#�#���	I��G�I�I�
I�����g�&�&�M��K�L�L�L��q�y�&������
�
�"�%�		&�	&�	&�
	��'�5�)�)�A��E�M�2��v�;�;�)�#�#�
��4��V���-�-�.�.��!�<��:�
�
�
���
����01��t�G�}�}�g�u�,�-��Hs!�;�
A�A�<'D$�$D>�=D>c�,�tj||��S�N)r�parse_template)rGr@s  r<rRrR1s���!�$��0�0�0r;c�V�tj||��}tj||��Srx)rry�expand_template)r@rrs   r<�_expandr|6s'���%�h��8�8�H��"�8�U�3�3�3r;c��t||��}|ds't|d��dkr|ddS|fd�}|S)Nrrc�,�tj||��Srx)rr{)rrs  r<�filterz_subx.<locals>.filterAs���&�x��7�7�7r;)rRrp)r@rrs   r<�_subxr�;s]���X�w�/�/�H��A�;��3�x��{�+�+�q�0�0���{�1�~��'�8�8�8�8��Mr;c�,�t|j|jffSrx)r>r@rB)rvs r<�_pickler�Is���a�i���)�)�)r;c��eZdZdd�Zd�ZdS)�Scannerrc���ddlm}m}t|t��r|j}||_g}tj��}||_	|D]w\}}|�
��}	|�tj|||	ddtj
||��ffg����|�|	|d���xtj||d|ffg��}tj|��|_dS)Nr)�BRANCH�
SUBPATTERNr���)�
_constantsr�r�rcr$rj�lexiconr�StaterB�	opengroup�append�
SubPattern�parse�
closegrouprr�scanner)
�selfr�rBr�r�rv�s�phrase�action�gids
          r<�__init__zScanner.__init__Rs��2�2�2�2�2�2�2�2��e�Y�'�'�	 ��K�E�������M�O�O�����%�	%�	%�N�F�F��+�+�-�-�C�
�H�H�W�'���c�1�a���v�u�)E�)E�F�G�,���
�
�
�
�L�L��a��e�$�$�$�$���q�F�T�1�I�#6�"7�8�8�� �(��+�+����r;c�~�g}|j}|j�|��j}d}	|��}|snz|���}||krn_|j|jdz
d}t
|��r%||_|||�����}|�||��|}��|||d�fS)NrTr)r�r�r�endr��	lastindex�callable�group)	r�rA�resultr�rr_�m�jr�s	         r<�scanzScanner.scancs����������$�$�V�,�,�2��
��
	�����A��
�������A��A�v�v���\�!�+�a�-�0��3�F�����
1���
����a�g�g�i�i�0�0���!���v�����A�
	��v�a�b�b�z�!�!r;N�r)r'r(r)r�r�r:r;r<r�r�Qs7������,�,�,�,�""�"�"�"�"r;r�r�)rr))�__doc__�enumrhrr�	functools�__all__�__version__�global_enum�_simple_enum�IntFlag�KEEPr$rrrrr	r
rrr
rrrrfrrkrrrPrqr>�	lru_cacherRr|r��copyregr��pickler�r:r;r<�<module>r�s���"i�i�V���� � � � � � � � ����������������4�<�$�)�4�4�4�
�
�
�
�
�
�
�5�4���
� 	���
2�2�2�2�
6�6�6�6�
3�3�3�3�
=�=�=�=�	>�	>�	>�	>�<�<�<�<�4�4�4�4�5�5�5�5�$�$�$�$� � � �

*�
*�
*�
*�"S�R�0Q�R�R�R��F�F�F��$� �y� ��Q�'�'�
(�
(����
�Y�
�r�1�
%�
%�
+�
+�B�
/�
/�0�0��

���	�
�
�
�B���Y���1�1� ��1�4�4�4�
�������*�*�*����w���*�*�*�
%"�%"�%"�%"�%"�%"�%"�%"�%"�%"r;PKV*]�@�����#__pycache__/_parser.cpython-311.pycnu�[����

o{������dZddlTdZdZed��Zed��Zed��Zed��Zed	��Z	ee
eeh��Z
eeeeeeeh��Zeed
��feed��feed��feed
��feed��feed��feed��feed��fd�Zeefeefeefeeefgfeeefgfeeefgfeeefgfeeefgfeee fgfee!fd�
Z"e#e$e%e&e'e(e)e*d�Z+e(e$ze*zZ,e-e)zZ.dZ/Gd�d��Z0Gd�d��Z1Gd�d��Z2d�Z3d�Z4d�Z5d�Z6d)d!�Z7d"�Z8d#�Z9d*d&�Z:d'�Z;d(�Z<d%S)+zInternal support module for sre�)�*z.\[{()*+?^$|z*+?{�
0123456789�01234567�0123456789abcdefABCDEF�4abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZz 	

����
�
�	��\)z\a�\bz\fz\nz\rz\tz\vz\\)
z\Arz\Bz\dz\Dz\sz\Sz\wz\Wz\Z)�i�L�m�s�x�a�t�ulc�D�eZdZd�Zed���Zdd�Zd�Zd�Zd�Z	dS)	�Statec�N�d|_i|_dg|_d|_i|_dS)N�)�flags�	groupdict�groupwidths�lookbehindgroups�grouprefpos��selfs �5/opt/alt/python-internal/lib/python3.11/re/_parser.py�__init__zState.__init__Ms0����
���� �6��� $��������c�*�t|j��S�N)�lenrr"s r$�groupszState.groupsSs���4�#�$�$�$r&Nc��|j}|j�d��|jtkrt	d���|�<|j�|d��}|�t	d|||fz���||j|<|S)Nztoo many groupsz7redefinition of group name %r as group %d; was group %d)r*r�append�	MAXGROUPS�errorr�get)r#�name�gid�ogids    r$�	opengroupzState.opengroupVs����k�������%�%�%��;��"�"��)�*�*�*����>�%�%�d�D�1�1�D����+�.2�C�$�-?�@�A�A�A�#&�D�N�4� ��
r&c�>�|���|j|<dSr()�getwidthr)r#r1�ps   r$�
closegroupzState.closegroupbs�� !�
�
��������r&c�6�||jko|j|duSr()r*r)r#r1s  r$�
checkgroupzState.checkgroupds!���T�[� �F�T�%5�c�%:�$�%F�Fr&c��|j�J|�|��s|�d���||jkr|�d���dSdS)N�cannot refer to an open groupz?cannot refer to group defined in the same lookbehind subpattern)r r9r.)r#r1�sources   r$�checklookbehindgroupzState.checklookbehindgroupgsl��� �,��?�?�3�'�'�
D��l�l�#B�C�C�C��d�+�+�+��l�l�$;�<�<�<�	-�,�,�+r&r()
�__name__�
__module__�__qualname__r%�propertyr*r3r7r9r=�r&r$rrKs�����������%�%��X�%�����-�-�-�G�G�G�<�<�<�<�<r&rc�N�eZdZd
d�Zdd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�ZdS)�
SubPatternNc�8�||_|�g}||_d|_dSr()�state�data�width)r#rFrGs   r$r%zSubPattern.__init__qs%����
��<��D���	���
�
�
r&rc�`�ttf}|jD�]\}}t|dzt	|��zd���|t
ur=t��|D]+\}}t|dzdzt	|��z|���,�p|turYt��t|d��D]4\}}|rt|dzdz��|�|dz���5��|tur_|\}}}	td|��|�|dz��|	r-t|dzdz��|	�|dz����:t|t��r(t��|�|dz����wt||��rd}
|D]h}t|t��r+|
st��|�|dz��d}
�B|
std	d���t|d���d}
�i|
st����td|����dS)
Nz  �)�endr�OR�ELSEFT� )�tuple�listrG�print�str�IN�BRANCH�	enumerate�dump�GROUPREF_EXISTS�
isinstancerD)r#�level�seqtypes�op�avrr�	condgroup�item_yes�item_no�nls           r$rVzSubPattern.dumpxsi���4�=���i�'	�'	�F�B���%��*�s�2�w�w�&�B�/�/�/�/��R�x�x������7�7�E�B���5��7�D�.�3�r�7�7�2�A�6�6�6�6�7��v�������%�b��e�,�,�$�$�D�A�q��1��e�D�j�4�/�0�0�0��F�F�5��7�O�O�O�O�$���&�&�/1�,�	�8�W��b�)�$�$�$��
�
�e�A�g�&�&�&��*��%��*�v�-�.�.�.��L�L��q��)�)�)���B�
�+�+�
���������a�� � � � ��B��)�)�
����
#�
#�A�!�!�Z�0�0�	#�!�$�!�G�G�G����u�Q�w����!���!�/�!�#�2�.�.�.�.��a�R�(�(�(�(�"������G�G�G���b�"�
�
�
�
�O'	�'	r&c�*�t|j��Sr()�reprrGr"s r$�__repr__zSubPattern.__repr__�s���D�I���r&c�*�t|j��Sr()r)rGr"s r$�__len__zSubPattern.__len__�s���4�9�~�~�r&c��|j|=dSr(�rG�r#�indexs  r$�__delitem__zSubPattern.__delitem__�s���I�e���r&c��t|t��r t|j|j|��S|j|Sr()rX�slicerDrFrGrhs  r$�__getitem__zSubPattern.__getitem__�s:���e�U�#�#�	<��d�j�$�)�E�*:�;�;�;��y���r&c��||j|<dSr(rg�r#ri�codes   r$�__setitem__zSubPattern.__setitem__�s����	�%���r&c�<�|j�||��dSr()rG�insertros   r$rszSubPattern.insert�s ���	�����%�%�%�%�%r&c�:�|j�|��dSr()rGr,)r#rps  r$r,zSubPattern.append�s���	��������r&c�n�|j�|jSdx}}|jD�]�\}}|turVt}d}|dD]9}|���\}}t||��}t
||��}�:||z}||z}�e|tur"|���\}}||z}||z}��|tur(|d���\}}||z}||z}��|tvrW|d���\}}|||dzz}|dtkr|r	t}��|||dzz}��!|tvr|dz}|dz}��6|tur!|j
j|\}}||z}||z}��`|turq|d���\}}|d�>|d���\}}t||��}t
||��}nd}||z}||z}���|t urn���t|t��t|t��f|_|jS)Nrr����)rHrGrT�MAXWIDTHr5�min�max�ATOMIC_GROUP�
SUBPATTERN�_REPEATCODES�	MAXREPEAT�
_UNITCODES�GROUPREFrFrrW�SUCCESS)	r#�lo�hir[r\r�j�l�hs	         r$r5zSubPattern.getwidth�s`���:�!��:�����R��i�+	�+	�F�B���V�|�|������Q�%�"�"�B��;�;�=�=�D�A�q��A�q�	�	�A��A�q�	�	�A�A��!�V���!�V����|�#�#��{�{�}�}���1��!�V���!�V����z�!�!��"�v���(�(���1��!�V���!�V����|�#�#��!�u�~�~�'�'���1��!�b��e�)�^���a�5�I�%�%�!�%�!�B�B��a�"�Q�%�i��B�B��z�!�!��!�V���!�V����x����z�-�b�1���1��!�V���!�V�����&�&��!�u�~�~�'�'���1��a�5�$��a�5�>�>�+�+�D�A�q��A�q�	�	�A��A�q�	�	�A�A��A��!�V���!�V����w��������X�&�&��B��(9�(9�9��
��z�r&r(�r)
r>r?r@r%rVrcrerjrmrqrsr,r5rBr&r$rDrDos�����������)�)�)�)�T��������� � � � � � �&�&�&����2�2�2�2�2r&rDc�b�eZdZd�Zd�Zd�Zd�Zd�Zd�Ze	d���Z
d�Zd	�Zdd�Z
d�Zd
S)�	Tokenizerc���t|t��|_||_|jst|d��}||_d|_d|_|���dS)N�latin1r)rXrR�istext�string�decoded_stringri�next�_Tokenizer__next)r#r�s  r$r%zTokenizer.__init__�sZ�� ���-�-�������{�	+����*�*�F�$�����
���	����
�
�
�
�
r&c�2�|j}	|j|}n#t$rd|_YdSwxYw|dkrQ|dz
}	||j|z
}n:#t$r-t	d|jt
|j��dz
��d�wxYw|dz|_||_dS)Nrrzbad escape (end of pattern))rir��
IndexErrorr�r.r�r))r#ri�chars   r$�__nextzTokenizer.__next�s����
��	��&�u�-�D�D���	�	�	��D�I��F�F�	�����4�<�<��Q�J�E�
I���+�E�2�2�����
I�
I�
I��9� �K��T�[�)9�)9�A�)=�?�?�DH�I�
I�����Q�Y��
���	�	�	s�
�,�,�A�7Bc�H�||jkr|���dSdS)NTF�r�r�)r#r�s  r$�matchzTokenizer.matchs&���4�9����K�K�M�M�M��4��ur&c�<�|j}|���|Sr(r�)r#�thiss  r$r/z
Tokenizer.gets���y�����
�
�
��r&c�z�d}t|��D](}|j}||vrn||z
}|����)|S�NrJ)�ranger�r�)r#�n�charset�result�_�cs      r$�getwhilezTokenizer.getwhile	sP�����q���	�	�A��	�A��������a�K�F��K�K�M�M�M�M��
r&c��d}	|j}|���|�@|s|�d|z���|�d|zt|�����||kr|s|�d|zd���n||z
}��|S)NrJTzmissing zmissing %s, unterminated namer)r�r�r.r))r#�
terminatorr0r�r�s     r$�getuntilzTokenizer.getuntils�����	��	�A��K�K�M�M�M��y��8��*�*�Z�$�%6�7�7�7��j�j�!@�:�!M�!$�V���.�.�.��J����;��*�*�Z�$�%6��:�:�:���a�K�F�	��
r&c�>�|jt|jpd��z
Sr��rir)r�r"s r$�posz
Tokenizer.pos"s���z�C��	��R�0�0�0�0r&c�>�|jt|jpd��z
Sr�r�r"s r$�tellzTokenizer.tell%s���z�C��	��R�0�0�0�0r&c�<�||_|���dSr()rir�rhs  r$�seekzTokenizer.seek's����
����
�
�
�
�
r&rc��|js)|�dd���d��}t||j|���|z
��S)N�ascii�backslashreplace)r��encode�decoder.r�r�)r#�msg�offsets   r$r.zTokenizer.error+sP���{�	J��*�*�W�&8�9�9�@�@��I�I�C��S�$�+�t�y�y�{�{�V�';�<�<�<r&c�^�|���s+d|z}|�|t|��|z���|jsd|���sRddl}|�d||���t|��z
|z
fzt|dz���dSdSdS)N�bad character in group name %rrz-bad character in group name %a at position %d���
stacklevel)	�isidentifierr.r)r��isascii�warnings�warnr��DeprecationWarning)r#r0r��nestedr�r�s      r$�checkgroupnamezTokenizer.checkgroupname0s���� � �"�"�	6�2�T�9�C��*�*�S�#�d�)�)�f�"4�5�5�5���	�t�|�|�~�~�	��O�O�O��M�M�?��t�y�y�{�{�S��Y�Y�.��7�8�9�"�v��z�
�
�
�
�
�
�	�	�	�	r&Nr�)r>r?r@r%r�r�r/r�r�rAr�r�r�r.r�rBr&r$r�r��s������������� ���
��������� �1�1��X�1�1�1�1����=�=�=�=�

�
�
�
�
r&r�c��t�|��}|r|St�|��}|r|dtur|S	|dd�}|dkrv||�dt
��z
}t
|��dkr&|�d|zt
|�����tt|dd�d��fS|dkr}|j
rv||�dt
��z
}t
|��d	kr&|�d|zt
|�����tt|dd�d��fS|d
kr�|j
r�||�dt
��z
}t
|��dkr&|�d|zt
|�����t|dd�d��}t|��t|fS|d
kr�|j
r�ddl}|�
d��s|�d���|�dd��}	t|�|����}nL#t"t$f$r8|�d|zt
|��t
d��z��d�wxYwt|fS|t&vrk||�dt&��z
}t|dd�d��}|dkr&|�d|zt
|�����t|fS|t(vrt*�t
|��dkrK|t,vr&|�d|zt
|�����tt|d��fSn#t*$rYnwxYw|�d|zt
|�����)Nrrrwr��incomplete escape %s�r��U��
�N�{�	missing {�}�character name�undefined character name %r�\N{}��.octal escape value %s outside of range 0-0o377�
bad escape %s)�ESCAPESr/�
CATEGORIESrSr��	HEXDIGITSr)r.�LITERAL�intr��chr�unicodedatar�r��ord�lookup�KeyError�	TypeError�	OCTDIGITS�DIGITS�
ValueError�ASCIILETTERS)r<�escaperpr�r��charnames      r$�
_class_escaper�<s����;�;�v���D������>�>�&�!�!�D����Q��2�
�
���1
��1�Q�3�K����8�8��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�b� � ��l�l�#9�F�#B�C��K�K�P�P�P��F�1�2�2�J��#�#�A���F�F�F��A�:��
�#�X�X�&�-�X������<�<��$�$�
0��l�l�;�/�/�/����s�,<�=�=�H�
K���*�*�8�4�4�5�5�����i�(�
K�
K�
K��l�l�#@�8�#K�#&�x�=�=�3�w�<�<�#?�A�A�FJ�K�
K�����A�:��
�)�^�^��f�o�o�a��3�3�3�F��F�1�2�2�J��"�"�A��5�y�y��l�l�$3�5;�$<�=@��[�[�J�J�J��A�:��
�&�[�[����v�;�;�!����L� � ��l�l�?�V�#;�S��[�[�I�I�I��C��q�	�N�N�*�*����
�
�
���
����
�,�,���/��V���
=�
=�=sO�
BN�BN�BN�*AN�<"I�N�A	J(�(N�4A3N�(A-N�
N$�#N$c�	�t�|��}|r|St�|��}|r|S	|dd�}|dkrv||�dt��z
}t|��dkr&|�d|zt|�����tt|dd�d��fS|dkr}|j	rv||�dt��z
}t|��dkr&|�d|zt|�����tt|dd�d��fS|d	kr�|j	r�||�d
t��z
}t|��dkr&|�d|zt|�����t|dd�d��}t|��t|fS|dkr�|j	r�d
dl}|�d��s|�d���|�
dd��}	t|�|����}nL#t t"f$r8|�d|zt|��td��z��d�wxYwt|fS|dkr=||�dt$��z
}tt|dd�d
��fS|t&v�rW|jt&vr�||���z
}|dt$vr�|dt$vrr|jt$vrd||���z
}t|dd�d
��}|dkr&|�d|zt|�����t|fSt|dd���}||jkrW|�|��s#|�dt|�����|�||��t0|fS|�d|zt|��dz
���t|��dkrK|t2vr&|�d|zt|�����tt|d��fSn#t4$rYnwxYw|�d|zt|�����)Nrrwrr�r�r�rr�r�r�r�r�rr�r�r�r�r�r��0r�r�r;�invalid group reference %dr�)r�r/r�r�r�r)r.r�r�r�r�r�r�r�r�r�r�r�r�r�r�r*r9r=r�r�r�)r<r�rFrpr�r�r��groups        r$�_escaper�xs����>�>�&�!�!�D������;�;�v���D�����B
��1�Q�3�K����8�8��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�a����l�l�#9�F�#B�C��K�K�P�P�P��C��q�r�r�
�B�/�/�/�/�
�#�X�X�&�-�X��f�o�o�a��3�3�3�F��6�{�{�b� � ��l�l�#9�F�#B�C��K�K�P�P�P��F�1�2�2�J��#�#�A���F�F�F��A�:��
�#�X�X�&�-�X������<�<��$�$�
0��l�l�;�/�/�/����s�,<�=�=�H�
K���*�*�8�4�4�5�5�����i�(�
K�
K�
K��l�l�#@�8�#K�#&�x�=�=�3�w�<�<�#?�A�A�FJ�K�
K�����A�:��
�#�X�X��f�o�o�a��3�3�3�F��C��q�r�r�
�A�.�.�.�.�
�&�[�[��{�f�$�$��&�*�*�,�,�&���1�I��*�*�v�a�y�I�/E�/E��K�9�,�,��f�j�j�l�l�*�F��F�1�2�2�J��*�*�A��5�y�y�$�l�l�,;�=C�,D�+.�v�;�;�8�8�8�#�A�:�%���q�r�r�
�O�O�E��u�|�#�#��'�'��.�.�4� �,�,�'F�'*�6�{�{�4�4�4��*�*�5�&�9�9�9����&��,�,�;�e�C�S��[�[�ST�_�U�U�U��v�;�;�!����L� � ��l�l�?�V�#;�S��[�[�I�I�I��C��q�	�N�N�*�*����
�
�
���
����
�,�,���/��V���
=�
=�=s\�BR(�BR(�BR(�AR(�-"I�R(�A	J�R(�%AR(�(B>R(�'A8R(� BR(�(
R5�4R5c�P�tt�|����Sr()rP�dict�fromkeys)�itemss r$�_uniqr��s����
�
�e�$�$�%�%�%r&c	�:�g}|j}|j}|���}	|t||||dz|o|����|d��sn|s|jt
z}�At
|��dkr|dSt|��}	d}	|D]}
|
sn8|	�	|
d}	�|
d|	krn� |D]}
|
d=�|�|	���C	g}|D]x}
t
|
��dkrn�|
d\}}
|tur|�||
f���C|tur+|
ddtur|�|
���wn+|�tt|��f��|S|�td|ff��|S)NTr�|r)r,r�r��_parser�SRE_FLAG_VERBOSEr)rDr�rS�NEGATE�extendr�rT)r<rF�verboser�r��itemsappend�sourcematch�start�
subpattern�prefix�item�setr[r\s              r$�
_parse_subr��s��
�E��,�K��,�K��K�K�M�M�E�5���F�6�5�'�6�A�:�%�:�3�e�)�5�5�	6�	6�	6��{�3���	���	5��k�$4�4�G�
5��5�z�z�Q����Q�x���E�"�"�J�����
	�
	�D��
����~��a�����a��F�"�"���#�
�
�
����G�G����f�%�%�%��
�
�C������t�9�9��>�>��E��a����B�
��=�=��J�J��B�x� � � � �
�2�X�X�"�Q�%��(�&�0�0��J�J�r�N�N�N�N��E�	���2�u�S�z�z�*�+�+�+������v��e�}�-�.�.�.��r&Fc���t|��}|j}|j}|j}t}	t
}
	|j}|��n^|dvr�nX|��|r&|tvr�(|dkr	|��}|�|dkrn��D|ddkrt|||��}||���n�|tvr|t|
|��f���n�|dk�r�|���dz
}
g}|j}|jdkr9ddl}|�
d	|���zt|d
z���|d��}	|��}|�+|�d
|���|
z
���|dkr|r�n�|ddkrt!||��}ny|re|dvra|j|krVddl}|�
d|dkrdn|dkrdn	|dkrdnd|���dz
fzt|d
z���t|
|��f}|d���r�|��}|�+|�d
|���|
z
���|dkrE|dt"ur|dd}||��|t|
d��f���nd|ddkrt!||��}nT|dkr<ddl}|�
d|���dz
zt|d
z���t|
|��f}|dtks|dtkr>d|�d|��}|�|t	|��dzt	|��z���|d}|d}||kr>d|�d|��}|�|t	|��dzt	|��z���|t$||ff��n(|dt"ur|dd}||�����t'|��}|	|��dkrJ|ddtur5|r |t(|ddf���n?||d���n,|r|�dt,df��|t"|f���
n�|t.v�r�|���}
|dkrd\}}�n�|dkrdt0}}�n�|dkrdt0}}�ns|dk�rZ|jd kr|t|
|��f�����dt0}}d!x}}|jt2vr||��z
}|jt2v�|d"��r*|jt2vr||��z
}|jt2v�n|}|d ��s2|t|
|��f��|�|
�����|r)t7|��}|t0krt9d#���|rZt7|��}|t0krt9d#���||kr+|�d$|���|
z
���nt;d%|�����|r|d&d�}nd}|r|ddt<ur;|�d'|���|
z
t	|��z���|ddt>vr;|�d(|���|
z
t	|��z���|ddt@ur|dd\}}}}|�|s|s|}|d��rtB|||ff|d&<�n<|d��rtD|||ff|d&<�n tF|||ff|d&<�n|d)kr|tHdf���n�|d*k�r�|���dz
} d}!d+}"d}#d}d}|d���rf|��}|�|�d,���|d-k�rh|d.��r/|�%d/d0��}#|�&|#d|���n|d1��r�|�%d2d0��}#|�&|#d|��|j'�|#��}$|$�+d3|#z}|�|t	|#��dz���|�(|$��s&|�d4t	|#��dz���|�)|$|��|tT|$f�����|��}|�|�d,���|�d5|zt	|��dz���|d6krd+}!�n�|dkrE	|j�+|�d7|���| z
���|��d2krn�B�	��|d8vr�d}%|d.kre|��}|�|�d,���|d9vr)|�d:|zt	|��dz���d&}%|j+}&|&�|j,|_+t[||||dz��}|%dkr	|&�d|_+|d2��s+|�d;|���| z
���|d1kr|t\|%|ff��n|t^|%|ff���
��|d*k�r�|�%d2d0��}'|'�0��r`|�&|'d|��|j'�|'��}(|(�+d3|'z}|�|t	|'��dz����n�	t7|'��}(|(dkrtb�n:#tb$r-d<|'z}|�|t	|'��dz��d�wxYw|(s&|�d=t	|'��dz���|(tdkr+d>|(z}|�|t	|'��dz���|(|j3vr/|���t	|'��z
dz
|j3|(<|'�4��r|'�5��sqddl}|�
d?|j6rto|'��ntq|'��|���t	|'��z
dz
fztr|d
z���|�)|(|��tu||||dz��})|�d@��r6tu||||dz��}*|jd@kr|�dA���nd}*|�d2��s+|�d;|���| z
���|tv|(|)|*ff���
�o|d/krd+}!d}"n�|txvs|dkr[t{|||��}+|+�@|r|r+|�dB|���| z
���|j>t~z}�
��|+\}}d+}!n)|�dC|zt	|��dz���|!rU	|�@|#��}n@#t$r1},|�|,jAt	|#��dz��d�d},~,wwxYwd}|s
|t~zo
|t~z}-t[|||-|dz��}|�d2��s+|�d;|���| z
���|�|�B||��|"r|�J�|t�|f��ne|t@||||ff��nN|dkr|t<t�f��n0|dDkr|t<t�f��nt;dE|�������it�t	|����ddd&�D]-}.||.\}/}0|/t@ur|0\}}}}|�|s|s
|||.|.dz�<�.|S)FNTz|)�#rrr�[rz"Possible nested set at position %dr�r��^zunterminated character set�]z-&~|zPossible set %s at position %d�-�
difference�&�intersection�~zsymmetric difference�unionz&Possible set difference at position %drwzbad character range �?)rrr�+r�r�rJ�,z"the repetition number is too largez"min repeat greater than max repeatzunsupported quantifier rvznothing to repeatzmultiple repeat�.�(Fzunexpected end of pattern�P�<�>�
group name�=�)�unknown group name %rr;zunknown extension ?P�:zmissing ), unterminated commentz=!<z=!zunknown extension ?<z"missing ), unterminated subpatternr�zbad group numberr��-bad character in group name %s at position %dr�z/conditional backref with more than two branchesz/global flags not at the start of the expressionzunknown extension ?�$zunsupported special character )GrDr,r/r�r)r�r��
WHITESPACEr��
SPECIAL_CHARSr�r�r�r��
FutureWarningr.r�rS�RANGEr��NOT_LITERALrsr��REPEAT_CHARSr~r�r�r��
OverflowError�AssertionError�ATr}r|�
MIN_REPEAT�POSSESSIVE_REPEAT�
MAX_REPEAT�ANYr�r�rr9r=r�r r*r��ASSERT�
ASSERT_NOTr�r�r-r!�	isdecimalr�r�rbr�r�r�rW�FLAGS�_parse_flagsrr�r3r�r7r{�AT_BEGINNING�AT_ENDr�)1r<rFr�r��firstr��subpatternappend�	sourcegetr��_len�_ordr�rp�herer��	setappendr��negate�code1�that�code2r�r�r�ryrzr�r�r��	add_flags�	del_flagsr6r��capture�atomicr0r1�dirr �condnamer]r^r_r�err�sub_verboserr[r\s1                                                 r$r�r�s����E�"�"�J�"�(���
�I��,�K��D��D�lO��{���<���4�<�<���	�����		��z�!�!���s�{�{��$�9�;�;�D��|�t�t�|�|������7�d�?�?��6�4��/�/�D���T�"�"�"�"�
��
&�
&���g�t�t�D�z�z�2�3�3�3�3�
�S�[�[��;�;�=�=�1�$�D��C��
�I��{�c�!�!������
�
�8�6�;�;�=�=�H�!�f�q�j�����!�[��%�%�F�9
%� �y�{�{���<� �,�,�'C�'-�{�{�}�}�t�';�=�=�=��3�;�;�3�;���!�W��_�_�)�&�$�7�7�E�E��
�t�v�~�~�&�+��2E�2E�'���� �
�
�<�04������26�#�+�+���:>�#�+�+� 6� 6� '� &���
�
�� 1�@3�3�*�f�q�j�&����$�T�T�$�Z�Z�/�E��;�s�#�#�#%�$�9�;�;�D��|�$�l�l�+G�+1�;�;�=�=�4�+?�A�A�A��s�{�{� ��8�r�>�>�$)�!�H�Q�K�E�!�	�%�(�(�(�!�	�7�D�D��I�I�"6�7�7�7���A�w�$��� -�f�d� ;� ;����3�;�;�+�O�O�O�$�M�M� H�$*�K�K�M�M�A�$5�!7� -�&�1�*�*����
!(���d��� 3���Q�x�7�*�*�e�A�h�'�.A�.A��=A�T�T�4�4�H��$�l�l�3��D�	�	�A�
��D�	�	�0I�J�J�J��q��B��q��B��B�w�w�w�=A�T�T�4�4�H��$�l�l�3��D�	�	�A�
��D�	�	�0I�J�J�J��I�u�r�2�h�/�0�0�0�0��Q�x�2�~�~� %�a������I�e�$�$�$�s9
%�v��*�*�C��t�C�y�y�A�~�~�#�a�&��)�w�"6�"6��-�$�$�k�3�q�6�!�9�%=�>�>�>�>�$�$�S��V�,�,�,�,��2��J�J�q�6�4�.�1�1�1�!� �"�c��+�+�+�+�
�\�
!�
!��;�;�=�=�D��s�{�{����S�S������i�S��������i�S��������;�#�%�%�$�$�g�t�t�D�z�z�%:�;�;�;���i�S�����R��k�V�+�+��)�)�+�+�%�B��k�V�+�+��;�s�#�#�� �+��/�/��i�i�k�k�)��!�+��/�/���B�"�{�3�'�'��$�$�g�t�t�D�z�z�%:�;�;�;��K�K��%�%�%���R��b�'�'�C��i�'�'�+�,P�Q�Q�Q��A��b�'�'�C��i�'�'�+�,P�Q�Q�Q��S�y�y�$�l�l�+O�+1�;�;�=�=�4�+?�A�A�A��%�n�D�D�%J�K�K�K��
�!�"�#�#�������
E�4��7�1�:��+�+��l�l�#6�#)�;�;�=�=�4�#7�#�d�)�)�#C�E�E�E��A�w�q�z�\�)�)��l�l�#4�#)�;�;�=�=�4�#7�#�d�)�)�#C�E�E�E��A�w�q�z�Z�'�'�15�a����.��y�)�Q��=��=�9�=��D��{�3���
@�",�s�C��.>�!?�
�2�����S�!�!�
@�"3�c�3��5E�!F�
�2���#-�s�C��.>�!?�
�2���
�S�[�[���c�4�[�)�)�)�)�
�S�[�[��K�K�M�M�A�%�E��G��F��D��I��I��{�3���L
6� �y�{�{���<� �,�,�'B�C�C�C��3�;�;�"�{�3�'�'�:�%���s�L�A�A���-�-�d�A�v�>�>�>�>�$��S�)�)�:�%���s�L�A�A���-�-�d�A�v�>�>�>�#�o�1�1�$�7�7���;�"9�D�"@�C�"(�,�,�s�C��I�I��M�"B�"B�B�$�/�/��4�4�>�"(�,�,�/N�/2�4�y�y�1�}�#>�#>�>��2�2�3��?�?�?�(�(�(�C��9�9�9� � )�y�{�{���<�"(�,�,�/J�"K�"K�K�$�l�l�+A�D�+H�+.�t�9�9�q�=�:�:�:��S�[�[�#�G�G��S�[�[�"�!�;�.�"(�,�,�/P�/5�{�{�}�}�u�/D�#F�#F�F�$�9�;�;�#�-�-�!�"���U�]�]��C��s�{�{�(�y�{�{���<�"(�,�,�/J�"K�"K�K��t�+�+�"(�,�,�/E��/L�/2�4�y�y�1�}�#>�#>�>� ��+0�+A�(�+�3�5:�\�E�2�"�6�5�'�6�A�:�F�F�A��Q�w�w�+�3�59�E�2�&�;�s�+�+�B�$�l�l�+O�+1�;�;�=�=�5�+@�B�B�B��s�{�{�(�(�&�3��(�);�<�<�<�<�(�(�*�s�A�h�)?�@�@�@���S�[�[�%���s�L�A�A�H��,�,�.�.���-�-�h��6�B�B�B�$)�O�$7�$7��$A�$A�	�$�,�"9�H�"D�C�"(�,�,�s�C��M�M�A�4E�"F�"F�F�-�Q�(+�H�
�
�I�(�1�}�}�&0� 0� -��)�Q�Q�Q�"B�X�"M�C�"(�,�,�s�C��M�M�A�4E�"F�"F�D�P�Q���� )�B�"(�,�,�/A�/2�8�}�}�q�/@�#B�#B�B�$�	�1�1�">��"J�C�"(�,�,�s�C��M�M�A�4E�"F�"F�F�$�E�,=�=�=� &���
�
��H�
�
� =�� A�"�-�i�8�!)� 2� 2� 4� 4���9I�9I�9K�9K��+�O�O�O�$�M�M� O�39�=�!U��h����e�H�o�o�!'������X���!>��!B�!D�!D�!3�v��z�	*�����.�.�y�&�A�A�A�%�f�e�W�f�q�j�I�I�H��|�|�C�(�(�'�"(�����!��"L�"L��!�;�#�-�-�"(�,�,�/`�"a�"a�a�.�#'��!�<�<��,�,�B�$�l�l�+O�+1�;�;�=�=�5�+@�B�B�B�$�$�o�	�8�W�7U�%V�W�W�W���S�[�[�#�G�!�F�F��U�]�]�d�c�k�k�(����=�=�E��}�$�F�
�F�"(�,�,�0C�/5�{�{�}�}�u�/D�#F�#F�F�#(�+�0@�"@�� �+0�(�I�y�#�G�G� �,�,�'<�t�'C�'*�4�y�y�1�}�6�6�6��
�I�!�O�O�D�1�1�E�E���I�I�I� �,�,�s�w��D�	�	�A�
�>�>�D�H�����I������#�E�	�4D�(D�>� )�,<� <�=�
��6�5�+�v��z�B�B�A��<�<��$�$�
:��l�l�#G�#)�;�;�=�=�5�#8�:�:�:�� �� � ���*�*�*��
Q��}�}�}� � �,��!2�3�3�3�3� � �*�u�i��A�.N�!O�P�P�P�P�
�S�[�[���b�,�/�0�0�0�0�
�S�[�[���b�&�\�*�*�*�*�!�.�t�t�!M�N�N�N�YlO�^�3�z�?�?�
#�
#�D�D�b�D�
)�'�'���A����B�
����-/�*�E�9�i���}�Y�}�y�}�%&�
�1�a��c�6�"���s$�
m*�*7n!�y�
z�#,z�zc��|j}d}d}|dkr�	t|}|jr|dkrd}|�|���n|dkrd}|�|���||z}|tzr%|tz|krd}|�|���|��}|�|�d	���|d
vrnE|tvr;|���rdnd	}|�|t
|�������|dkr|xj|zc_dS|tzr|�d
d���|dk�r|��}|�|�d���|tvr;|���rdnd}|�|t
|�����	t|}|tzrd}|�|���||z}|��}|�|�d���|dkrnE|tvr;|���rdnd}|�|t
|�������|dksJ�|tzr|�dd���||zr|�dd���||fS)NrrTrz8bad inline flags: cannot use 'L' flag with a str patternrz:bad inline flags: cannot use 'u' flag with a bytes patternz9bad inline flags: flags 'a', 'u' and 'L' are incompatiblezmissing -, : or )z)-:zunknown flagrz,bad inline flags: cannot turn on global flagrzmissing flagz8bad inline flags: cannot turn off flags 'a', 'u' and 'L'z	missing :rz-bad inline flags: cannot turn off global flagz(bad inline flags: flag turned on and off)	r/r'r�r.�
TYPE_FLAGS�isalphar)r�GLOBAL_FLAGS)r<rFr�r-r6r7�flagr�s        r$r(r(�s����
�I��I��I��s�{�{�	3���;�D��}�
,��3�;�;�T�C� �,�,�s�+�+�+���3�;�;�V�C� �,�,�s�+�+�+����I��z�!�
(�	�J�(>�4�'G�'G�Q���l�l�3�'�'�'��9�;�;�D��|��l�l�#6�7�7�7��u�}�}���5� � �(,�����O�n�n�<O���l�l�3��D�	�	�2�2�2�+	3�,�s�{�{�
���y� ����t��<��N��l�l�I�1�M�M�M��s�{�{��y�{�{���<��,�,�~�.�.�.��u���$(�L�L�N�N�F�.�.��C��,�,�s�C��I�I�.�.�.�
	3���;�D��j� �
(�P���l�l�3�'�'�'����I��9�;�;�D��|��l�l�;�/�/�/��s�{�{���5� � �(,�����G�n�n�K���l�l�3��D�	�	�2�2�2�
	3��3�;�;�;�;��<��O��l�l�J�A�N�N�N��9��J��l�l�E�q�I�I�I��i��r&c�8�t|t��rH|tzrtd���|tzs|t
z}nV|t
zrtd���n<|t
zrtd���|tzr|tzrtd���|S)Nz)cannot use LOCALE flag with a str patternz(ASCII and UNICODE flags are incompatiblez,cannot use UNICODE flag with a bytes patternz'ASCII and LOCALE flags are incompatible)rXrR�SRE_FLAG_LOCALEr��SRE_FLAG_ASCII�SRE_FLAG_UNICODE)�srcrs  r$�	fix_flagsrH�s����#�s���H��?�"�	J��H�I�I�I��~�%�	I��%�%�E�E�
�%�
%�	I��G�H�H�H�	I��#�#�	M��K�L�L�L��?�"�	H�u�~�'=�	H��F�G�G�G��Lr&rNc���t|��}|�t��}||_||_t	|||t
zd��}t
||jj��|j_|j�"|jdksJ�|�	d���|jj
D]8}||jjkr&d|z}t|||jj
|����9|tzr|�
��|S)Nrrzunbalanced parenthesisr�)r�rrrRr�r�rHrFr�r.r!r*�SRE_FLAG_DEBUGrV)rRrrFr<r6�gr�s       r$�parserL�s����s�^�^�F��}������E�K��E�I��6�5�%�*:�":�A�>�>�A��c�1�7�=�1�1�A�G�M�
�{���{�c�!�!�!�!��l�l�3�4�4�4�
�W�
 �:�:��������.��2�C���S�!�'�"5�a�"8�9�9�9��
�~���	�������Hr&c	����
���t|����j}g�g�g�
�
j}��
���fd�}�j}	|��}|��n�|ddk�r�|d}|dk�rՉ�d��s��d�����d	d
��}|���rC��|dd��	||}	�nA#t$rtd|z��d�wxYw	t|��}	|	dkrt�n8#t$r+��d
|zt|��dz��d�wxYw|	tkr)��d|	zt|��dz���|���r|���snddl}
|
�d�jrt)|��nt+|������t|��z
dz
fzt.d���||	t|��dz���n�|dkri�jt2vr(||��z
}�jt2vr
||��z
}|t5t|dd�d��dz�����nd|t6vr�d}�jt6vr�||��z
}|t2vr�|dt2vry�jt2vrk||��z
}d}t|dd�d��}|dkr&��d|zt|�����|t5|����|s1|t|dd���t|��dz
��ny	t5t8|d��}n@#t$r3|t:vr'��d|zt|����d�YnwxYw||��n||����ԉ
r(��d��
����t?|t@��sd��D�����fS)Nc� ��|�jkr��d|z|����r-��d�������dd�=��t	���|f����d��dS)Nr�rJ)r*r.r,�joinr))rir�r*�literal�literalsrrFs  �����r$�addgroupz parse_template.<locals>.addgroup�s�����5�<����'�'�6��>��D�D�D��	��O�O�B�G�G�G�,�,�-�-�-�����
��
�
�s�8�}�}�e�,�-�-�-���������r&TrrrrKrz	missing <rrrvrr�r�r�r�r�r�r�Frwr�r�rJc�@�g|]}|�dn|�d����S)Nzlatin-1)r�)�.0rs  r$�
<listcomp>z"parse_template.<locals>.<listcomp>Hs,��Q�Q�Q�1�A�I�D�D�1�8�8�I�+>�+>�Q�Q�Qr&)!r�r/r,�
groupindexr�r.r�r�r�r�r�r�r�r)r-r&r�r�r�r�rbr�r�r�r�r�r�r�r�r�rOrXrR)r<rF�sget�lappendrRrWr�r�r0rir��isoctalr*rPrQrs `          @@@@r$�parse_templater[�s��������	�&���A��5�D�
�F��H��G��n�G�����������!�J�B��t�v�v���<����7�d�?�?��Q��A��C�x�x��w�w�s�|�|�/��'�'�+�.�.�.��z�z�#�|�4�4���$�$�&�&���$�$�T�1�b�1�1�1�S� *�4� 0����#�S�S�S�(�)@�4�)G�H�H�d�R�S����?� #�D�	�	�� �1�9�9�",�,�%��%�?�?�?��g�g�&F��&M�&)�$�i�i�!�m�5�5�:>�?�?�����	�)�)��g�g�&B�U�&J�&)�$�i�i�!�m�5�5�5� �N�N�,�,��������'���� �
�
�K�+,�8�D�T�$�Z�Z�Z��t����V�V�X�X��D�	�	�1�A�5�7�7�/�1�	&��������D�	�	�A�
�.�.�.�.��c����6�Y�&�&��D�D�F�F�N�D��v��*�*�����������C��Q�R�R��!�,�,�t�3�4�4�5�5�5�5��f������6�V�#�#��D�D�F�F�N�D��Y���4��7�i�+?�+?���)�+�+��������"&����Q�R�R��!�,�,���u�9�9�"#�'�'�+:�<@�+A�BE�d�)�)�#M�#M�M����A�������;��H�S��a�b�b��]�]�C��I�I��M�:�:�:��S��w�t�}�Q�/�0�0�D�D���S�S�S��L�(�(��g�g�o��&<�c�$�i�i�H�H�d�R�)�(�S�������
�
�
�
��G�D�M�M�M�EB�F�*��������(�(�)�)�)��f�c�"�"�R�R�Q��Q�Q�Q���8��s*�C�C8�<D�5E� N5�5:O2�1O2c���|j}|jdd�}|\}}|dd�}	|D]\}}||��p|||<�n!#t$rtd|z��d�wxYw|�|��S)Nrr�)r�r�r�r.rO)�templater�rK�emptyr*rQrir�s        r$�expand_templater_Ks���
��A��L��!���E���F�H�����{�H�D�"�	0�	0�L�E�5��a��h�h�/�%�H�U�O�O�	0���D�D�D��0�5�8�9�9�t�C�D�����:�:�h���s�A�A)F)rN)=�__doc__�
_constantsrr�	frozensetr�r�r�r�rr r"r!r}r#rrSr�r�CATEGORYrr�r�r�AT_BEGINNING_STRING�AT_BOUNDARY�AT_NON_BOUNDARY�CATEGORY_DIGIT�CATEGORY_NOT_DIGIT�CATEGORY_SPACE�CATEGORY_NOT_SPACE�
CATEGORY_WORD�CATEGORY_NOT_WORD�
AT_END_STRINGr��SRE_FLAG_IGNORECASErD�SRE_FLAG_MULTILINE�SRE_FLAG_DOTALLr�rE�SRE_FLAG_TEMPLATErFr'r?rJrArxrrDr�r�r�r�r�r�r(rHrLr[r_rBr&r$�<module>rrsT��&�%������
���	��<�	 �	 ���I�j�!�!�	��I�.�/�/�	��y�O�P�P��
�Y�}�
%�
%�
��y�*�j�2C�D�E�E��
�Y��U�B���h�G�
H�
H�
�
�S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y���S�S��Y�Y��	�	��
�#�$������ ��(�N�+�,�-��(�.�/�0�1��(�N�+�,�-��(�.�/�0�1��(�M�*�+�,��(�-�.�/�0��
����
�
�	�	�	�	�	�	�	�	�	���o�
-�0@�
@�
�� 1�1����"<�"<�"<�"<�"<�"<�"<�"<�Hu�u�u�u�u�u�u�u�nT�T�T�T�T�T�T�T�l:>�:>�:>�xK>�K>�K>�Z&�&�&�:�:�:�xA�A�A�A�F: �: �: �x��� 
�
�
�
�6[�[�[�z
 �
 �
 �
 �
 r&PKV*]���~JJ*__pycache__/_casefix.cpython-311.opt-2.pycnu�[����

]�)�����>�idd�dd�dd�dd�dd	�d
d�dd
�dd�dd�dd�dd�dd�dd�dd�dd�dd�d d!�id"d#�d$d%�d&d'�d(d)�d*d+�d,d-�d.d/�d0d1�d2d3�d4d5�d6d7�d8d9�d:d;�d<d=�d>d?�d@dA�dBdC��idDdE�dFdG�dHdI�dJdK�dLdM�dNdO�dPdQ�dRdS�dTdU�dVdW�dXdY�dZd[�d\d]�d^d_�d`da�dbdc��ZddS)e�i)�1�s)��)�r)rr)r�E)���)���)���)���)��)��r	)rr
�)��r)r�)���)����)��r)r��)��r)rr)rr)rr)rr)rr)rr)r�2)��4)��>)��A)��B)���J)��c)�r )rr")r!r$)r#r&)r%r()r'r)r))r'r(r+)r*r-)r,�)�K��a)�r1)r0r
)rr	r)rr)r
r/)r.��)��r3)r2N)�_EXTRA_CASES���6/opt/alt/python-internal/lib/python3.11/re/_casefix.py�<module>r8s���
e�
�I�e��I�	e��I�
e��I�e��I�e���e��I�e� �I�!e�$�I�%e�(�I�)e�,�I�-e�0��1e�4�I�5e�8�I�9e�<�I�=e�@�I�Ae�D�I�Ee�e�H�I�Ie�L�I�Me�P�I�Qe�T�I�Ue�X�I�Ye�\�I�]e�`�I�ae�d�I�ee�h�I�ie�l�I�me�p�I�qe�t�I�ue�x�I�ye�|��}e�@�I�Ae�D�I�Ee�H�I�Ie�e�e�L�I�Me�P�I�Qe�T�I�Ue�X��Ye�\��]e�`�I�ae�d�I�ee�h�I�ie�l�I�me�p�I�qe�t��ue�x�I�ye�|�I�}e�@�I�Ae�D�I�Ee�H�I�Ie�e���r6PKV*]����**
_constants.pynu�[���#
# Secret Labs' Regular Expression Engine
#
# various symbols used by the regular expression engine.
# run this script to update the _sre include files!
#
# Copyright (c) 1998-2001 by Secret Labs AB.  All rights reserved.
#
# See the __init__.py file for information on usage and redistribution.
#

"""Internal support module for sre"""

# update when constants are added or removed

MAGIC = 20220615

from _sre import MAXREPEAT, MAXGROUPS

# SRE standard exception (access as sre.error)
# should this really be here?

class error(Exception):
    """Exception raised for invalid regular expressions.

    Attributes:

        msg: The unformatted error message
        pattern: The regular expression pattern
        pos: The index in the pattern where compilation failed (may be None)
        lineno: The line corresponding to pos (may be None)
        colno: The column corresponding to pos (may be None)
    """

    __module__ = 're'

    def __init__(self, msg, pattern=None, pos=None):
        self.msg = msg
        self.pattern = pattern
        self.pos = pos
        if pattern is not None and pos is not None:
            msg = '%s at position %d' % (msg, pos)
            if isinstance(pattern, str):
                newline = '\n'
            else:
                newline = b'\n'
            self.lineno = pattern.count(newline, 0, pos) + 1
            self.colno = pos - pattern.rfind(newline, 0, pos)
            if newline in pattern:
                msg = '%s (line %d, column %d)' % (msg, self.lineno, self.colno)
        else:
            self.lineno = self.colno = None
        super().__init__(msg)


class _NamedIntConstant(int):
    def __new__(cls, value, name):
        self = super(_NamedIntConstant, cls).__new__(cls, value)
        self.name = name
        return self

    def __repr__(self):
        return self.name

    __reduce__ = None

MAXREPEAT = _NamedIntConstant(MAXREPEAT, 'MAXREPEAT')

def _makecodes(*names):
    items = [_NamedIntConstant(i, name) for i, name in enumerate(names)]
    globals().update({item.name: item for item in items})
    return items

# operators
OPCODES = _makecodes(
    # failure=0 success=1 (just because it looks better that way :-)
    'FAILURE', 'SUCCESS',

    'ANY', 'ANY_ALL',
    'ASSERT', 'ASSERT_NOT',
    'AT',
    'BRANCH',
    'CATEGORY',
    'CHARSET', 'BIGCHARSET',
    'GROUPREF', 'GROUPREF_EXISTS',
    'IN',
    'INFO',
    'JUMP',
    'LITERAL',
    'MARK',
    'MAX_UNTIL',
    'MIN_UNTIL',
    'NOT_LITERAL',
    'NEGATE',
    'RANGE',
    'REPEAT',
    'REPEAT_ONE',
    'SUBPATTERN',
    'MIN_REPEAT_ONE',
    'ATOMIC_GROUP',
    'POSSESSIVE_REPEAT',
    'POSSESSIVE_REPEAT_ONE',

    'GROUPREF_IGNORE',
    'IN_IGNORE',
    'LITERAL_IGNORE',
    'NOT_LITERAL_IGNORE',

    'GROUPREF_LOC_IGNORE',
    'IN_LOC_IGNORE',
    'LITERAL_LOC_IGNORE',
    'NOT_LITERAL_LOC_IGNORE',

    'GROUPREF_UNI_IGNORE',
    'IN_UNI_IGNORE',
    'LITERAL_UNI_IGNORE',
    'NOT_LITERAL_UNI_IGNORE',
    'RANGE_UNI_IGNORE',

    # The following opcodes are only occurred in the parser output,
    # but not in the compiled code.
    'MIN_REPEAT', 'MAX_REPEAT',
)
del OPCODES[-2:] # remove MIN_REPEAT and MAX_REPEAT

# positions
ATCODES = _makecodes(
    'AT_BEGINNING', 'AT_BEGINNING_LINE', 'AT_BEGINNING_STRING',
    'AT_BOUNDARY', 'AT_NON_BOUNDARY',
    'AT_END', 'AT_END_LINE', 'AT_END_STRING',

    'AT_LOC_BOUNDARY', 'AT_LOC_NON_BOUNDARY',

    'AT_UNI_BOUNDARY', 'AT_UNI_NON_BOUNDARY',
)

# categories
CHCODES = _makecodes(
    'CATEGORY_DIGIT', 'CATEGORY_NOT_DIGIT',
    'CATEGORY_SPACE', 'CATEGORY_NOT_SPACE',
    'CATEGORY_WORD', 'CATEGORY_NOT_WORD',
    'CATEGORY_LINEBREAK', 'CATEGORY_NOT_LINEBREAK',

    'CATEGORY_LOC_WORD', 'CATEGORY_LOC_NOT_WORD',

    'CATEGORY_UNI_DIGIT', 'CATEGORY_UNI_NOT_DIGIT',
    'CATEGORY_UNI_SPACE', 'CATEGORY_UNI_NOT_SPACE',
    'CATEGORY_UNI_WORD', 'CATEGORY_UNI_NOT_WORD',
    'CATEGORY_UNI_LINEBREAK', 'CATEGORY_UNI_NOT_LINEBREAK',
)


# replacement operations for "ignore case" mode
OP_IGNORE = {
    LITERAL: LITERAL_IGNORE,
    NOT_LITERAL: NOT_LITERAL_IGNORE,
}

OP_LOCALE_IGNORE = {
    LITERAL: LITERAL_LOC_IGNORE,
    NOT_LITERAL: NOT_LITERAL_LOC_IGNORE,
}

OP_UNICODE_IGNORE = {
    LITERAL: LITERAL_UNI_IGNORE,
    NOT_LITERAL: NOT_LITERAL_UNI_IGNORE,
}

AT_MULTILINE = {
    AT_BEGINNING: AT_BEGINNING_LINE,
    AT_END: AT_END_LINE
}

AT_LOCALE = {
    AT_BOUNDARY: AT_LOC_BOUNDARY,
    AT_NON_BOUNDARY: AT_LOC_NON_BOUNDARY
}

AT_UNICODE = {
    AT_BOUNDARY: AT_UNI_BOUNDARY,
    AT_NON_BOUNDARY: AT_UNI_NON_BOUNDARY
}

CH_LOCALE = {
    CATEGORY_DIGIT: CATEGORY_DIGIT,
    CATEGORY_NOT_DIGIT: CATEGORY_NOT_DIGIT,
    CATEGORY_SPACE: CATEGORY_SPACE,
    CATEGORY_NOT_SPACE: CATEGORY_NOT_SPACE,
    CATEGORY_WORD: CATEGORY_LOC_WORD,
    CATEGORY_NOT_WORD: CATEGORY_LOC_NOT_WORD,
    CATEGORY_LINEBREAK: CATEGORY_LINEBREAK,
    CATEGORY_NOT_LINEBREAK: CATEGORY_NOT_LINEBREAK
}

CH_UNICODE = {
    CATEGORY_DIGIT: CATEGORY_UNI_DIGIT,
    CATEGORY_NOT_DIGIT: CATEGORY_UNI_NOT_DIGIT,
    CATEGORY_SPACE: CATEGORY_UNI_SPACE,
    CATEGORY_NOT_SPACE: CATEGORY_UNI_NOT_SPACE,
    CATEGORY_WORD: CATEGORY_UNI_WORD,
    CATEGORY_NOT_WORD: CATEGORY_UNI_NOT_WORD,
    CATEGORY_LINEBREAK: CATEGORY_UNI_LINEBREAK,
    CATEGORY_NOT_LINEBREAK: CATEGORY_UNI_NOT_LINEBREAK
}

# flags
SRE_FLAG_TEMPLATE = 1 # template mode (unknown purpose, deprecated)
SRE_FLAG_IGNORECASE = 2 # case insensitive
SRE_FLAG_LOCALE = 4 # honour system locale
SRE_FLAG_MULTILINE = 8 # treat target as multiline string
SRE_FLAG_DOTALL = 16 # treat target as a single string
SRE_FLAG_UNICODE = 32 # use unicode "locale"
SRE_FLAG_VERBOSE = 64 # ignore whitespace and comments
SRE_FLAG_DEBUG = 128 # debugging
SRE_FLAG_ASCII = 256 # use ascii "locale"

# flags for INFO primitive
SRE_INFO_PREFIX = 1 # has prefix
SRE_INFO_LITERAL = 2 # entire pattern is literal (given by prefix)
SRE_INFO_CHARSET = 4 # pattern starts with character from given set
PKV*]�[����
_parser.pynu�[���PKV*]w7�e�e�_compiler.pynu�[���PKV*]L�\>>__init__.pynu�[���PKV*]>�+FF_J_casefix.pynu�[���PKV*]��RR,�___pycache__/_constants.cpython-311.opt-1.pycnu�[���PKV*]F�G��,�w__pycache__/_constants.cpython-311.opt-2.pycnu�[���PKV*]��RR&��__pycache__/_constants.cpython-311.pycnu�[���PKV*]��_ΆK�K$;�__pycache__/__init__.cpython-311.pycnu�[���PKV*]ķ��z�z+�__pycache__/_compiler.cpython-311.opt-1.pycnu�[���PKV*]�ـ�|�|%8l__pycache__/_compiler.cpython-311.pycnu�[���PKV*]�\��,+,+*�__pycache__/__init__.cpython-311.opt-2.pycnu�[���PKV*]���~JJ$�__pycache__/_casefix.cpython-311.pycnu�[���PKV*]���~JJ*@__pycache__/_casefix.cpython-311.opt-1.pycnu�[���PKV*]�*@Mb�b�)�#__pycache__/_parser.cpython-311.opt-2.pycnu�[���PKV*](nmd2y2y+��__pycache__/_compiler.cpython-311.opt-2.pycnu�[���PKV*]z~�����),a__pycache__/_parser.cpython-311.opt-1.pycnu�[���PKV*]��_ΆK�K*%__pycache__/__init__.cpython-311.opt-1.pycnu�[���PKV*]�@�����#�p__pycache__/_parser.cpython-311.pycnu�[���PKV*]���~JJ*:5__pycache__/_casefix.cpython-311.opt-2.pycnu�[���PKV*]����**
�<_constants.pynu�[���PK�ET