golden hour

/usr/lib64/python2.7

File/Folder	Size	Actions
BaseHTTPServer.py	21.93 KB
BaseHTTPServer.pyc	21.18 KB
BaseHTTPServer.pyo	21.18 KB
Bastion.py	5.61 KB
Bastion.pyc	6.5 KB
Bastion.pyo	6.5 KB
CGIHTTPServer.py	12.84 KB
CGIHTTPServer.pyc	10.84 KB
CGIHTTPServer.pyo	10.84 KB
ConfigParser.py	27.1 KB
ConfigParser.pyc	24.62 KB
ConfigParser.pyo	24.62 KB
Cookie.py	24.66 KB
Cookie.pyc	21.64 KB
Cookie.pyo	21.64 KB
Demo	-
Doc	-
DocXMLRPCServer.py	10.52 KB
DocXMLRPCServer.pyc	9.96 KB
DocXMLRPCServer.pyo	9.85 KB
HTMLParser.py	16.58 KB
HTMLParser.pyc	13.39 KB
HTMLParser.pyo	13.1 KB
MimeWriter.py	6.33 KB
MimeWriter.pyc	7.19 KB
MimeWriter.pyo	7.19 KB
Queue.py	8.36 KB
Queue.pyc	9.19 KB
Queue.pyo	9.19 KB
SimpleHTTPServer.py	7.25 KB
SimpleHTTPServer.pyc	7.55 KB
SimpleHTTPServer.pyo	7.55 KB
SimpleXMLRPCServer.py	25.17 KB
SimpleXMLRPCServer.pyc	22.31 KB
SimpleXMLRPCServer.pyo	22.31 KB
SocketServer.py	23.29 KB
SocketServer.pyc	23.49 KB
SocketServer.pyo	23.49 KB
StringIO.py	10.41 KB
StringIO.pyc	11.21 KB
StringIO.pyo	11.21 KB
Tools	-
UserDict.py	5.67 KB
UserDict.pyc	8.61 KB
UserDict.pyo	8.61 KB
UserList.py	3.56 KB
UserList.pyc	6.42 KB
UserList.pyo	6.42 KB
UserString.py	9.46 KB
UserString.pyc	14.52 KB
UserString.pyo	14.52 KB
_LWPCookieJar.py	6.4 KB
_LWPCookieJar.pyc	5.4 KB
_LWPCookieJar.pyo	5.4 KB
_MozillaCookieJar.py	5.67 KB
_MozillaCookieJar.pyc	4.37 KB
_MozillaCookieJar.pyo	4.33 KB
__future__.py	4.28 KB
__future__.pyc	4.13 KB
__future__.pyo	4.13 KB
__phello__.foo.py	64 B
__phello__.foo.pyc	125 B
__phello__.foo.pyo	125 B
_abcoll.py	17.45 KB
_abcoll.pyc	24.4 KB
_abcoll.pyo	24.4 KB
_osx_support.py	18.03 KB
_osx_support.pyc	11.28 KB
_osx_support.pyo	11.28 KB
_pyio.py	67.24 KB
_pyio.pyc	62.71 KB
_pyio.pyo	62.71 KB
_strptime.py	19.75 KB
_strptime.pyc	14.53 KB
_strptime.pyo	14.53 KB
_sysconfigdata.py	17.56 KB
_sysconfigdata.pyc	20.72 KB
_sysconfigdata.pyo	20.72 KB
_threading_local.py	7.28 KB
_threading_local.pyc	6.45 KB
_threading_local.pyo	6.45 KB
_weakrefset.py	5.48 KB
_weakrefset.pyc	9.25 KB
_weakrefset.pyo	9.25 KB
abc.py	6.98 KB
abc.pyc	6 KB
abc.pyo	5.94 KB
aifc.py	32.94 KB
aifc.pyc	29.31 KB
aifc.pyo	29.31 KB
antigravity.py	60 B
antigravity.pyc	203 B
antigravity.pyo	203 B
anydbm.py	2.6 KB
anydbm.pyc	2.73 KB
anydbm.pyo	2.73 KB
argparse.py	86.46 KB
argparse.pyc	62.57 KB
argparse.pyo	62.41 KB
ast.py	11.53 KB
ast.pyc	12.65 KB
ast.pyo	12.65 KB
asynchat.py	11.13 KB
asynchat.pyc	8.44 KB
asynchat.pyo	8.44 KB
asyncore.py	20.36 KB
asyncore.pyc	18.4 KB
asyncore.pyo	18.4 KB
atexit.py	1.67 KB
atexit.pyc	2.15 KB
atexit.pyo	2.15 KB
audiodev.py	7.42 KB
audiodev.pyc	8.27 KB
audiodev.pyo	8.27 KB
base64.py	11.09 KB
base64.pyc	10.63 KB
base64.pyo	10.63 KB
bdb.py	21.21 KB
bdb.pyc	18.65 KB
bdb.pyo	18.65 KB
binhex.py	14.14 KB
binhex.pyc	15.04 KB
binhex.pyo	15.04 KB
bisect.py	2.53 KB
bisect.pyc	3 KB
bisect.pyo	3 KB
bsddb	-
cProfile.py	6.43 KB
cProfile.pyc	6.25 KB
cProfile.pyo	6.25 KB
calendar.py	22.76 KB
calendar.pyc	27.13 KB
calendar.pyo	27.13 KB
cgi.py	34.31 KB
cgi.pyc	31.99 KB
cgi.pyo	31.99 KB
cgitb.py	11.89 KB
cgitb.pyc	11.9 KB
cgitb.pyo	11.9 KB
chunk.py	5.25 KB
chunk.pyc	5.46 KB
chunk.pyo	5.46 KB
cmd.py	14.67 KB
cmd.pyc	13.71 KB
cmd.pyo	13.71 KB
code.py	9.95 KB
code.pyc	10.09 KB
code.pyo	10.09 KB
codecs.py	34.44 KB
codecs.pyc	35.74 KB
codecs.pyo	35.74 KB
codeop.py	5.86 KB
codeop.pyc	6.44 KB
codeop.pyo	6.44 KB
collections.py	25.28 KB
collections.pyc	23.99 KB
collections.pyo	23.94 KB
colorsys.py	3.6 KB
colorsys.pyc	3.9 KB
colorsys.pyo	3.9 KB
commands.py	2.49 KB
commands.pyc	2.41 KB
commands.pyo	2.41 KB
compileall.py	7.58 KB
compileall.pyc	6.85 KB
compileall.pyo	6.85 KB
compiler	-
config	-
contextlib.py	4.32 KB
contextlib.pyc	4.35 KB
contextlib.pyo	4.35 KB
cookielib.py	63.21 KB
cookielib.pyc	53.55 KB
cookielib.pyo	53.37 KB
copy.py	11.25 KB
copy.pyc	11.91 KB
copy.pyo	11.82 KB
copy_reg.py	6.64 KB
copy_reg.pyc	4.99 KB
copy_reg.pyo	4.95 KB
crypt.py	2.24 KB
crypt.pyc	2.89 KB
crypt.pyo	2.89 KB
csv.py	15.96 KB
csv.pyc	13.14 KB
csv.pyo	13.14 KB
ctypes	-
curses	-
dbhash.py	498 B
dbhash.pyc	718 B
dbhash.pyo	718 B
decimal.py	215.84 KB
decimal.pyc	167.33 KB
decimal.pyo	167.33 KB
difflib.py	80.42 KB
difflib.pyc	60.5 KB
difflib.pyo	60.45 KB
dircache.py	1.1 KB
dircache.pyc	1.54 KB
dircache.pyo	1.54 KB
dis.py	6.35 KB
dis.pyc	6.08 KB
dis.pyo	6.08 KB
distutils	-
doctest.py	102.01 KB
doctest.pyc	81.45 KB
doctest.pyo	81.17 KB
dumbdbm.py	8.61 KB
dumbdbm.pyc	6.41 KB
dumbdbm.pyo	6.41 KB
dummy_thread.py	4.31 KB
dummy_thread.pyc	5.27 KB
dummy_thread.pyo	5.27 KB
dummy_threading.py	2.74 KB
dummy_threading.pyc	1.25 KB
dummy_threading.pyo	1.25 KB
email	-
encodings	-
filecmp.py	9.36 KB
filecmp.pyc	9.4 KB
filecmp.pyo	9.4 KB
fileinput.py	13.81 KB
fileinput.pyc	14.48 KB
fileinput.pyo	14.48 KB
fnmatch.py	3.16 KB
fnmatch.pyc	3.45 KB
fnmatch.pyo	3.45 KB
formatter.py	14.56 KB
formatter.pyc	18.73 KB
formatter.pyo	18.73 KB
fpformat.py	4.59 KB
fpformat.pyc	4.56 KB
fpformat.pyo	4.56 KB
fractions.py	21.87 KB
fractions.pyc	19.27 KB
fractions.pyo	19.27 KB
ftplib.py	36.1 KB
ftplib.pyc	33.38 KB
ftplib.pyo	33.38 KB
functools.py	4.37 KB
functools.pyc	5.95 KB
functools.pyo	5.95 KB
genericpath.py	2.94 KB
genericpath.pyc	3.19 KB
genericpath.pyo	3.19 KB
getopt.py	7.15 KB
getopt.pyc	6.5 KB
getopt.pyo	6.45 KB
getpass.py	5.43 KB
getpass.pyc	4.63 KB
getpass.pyo	4.63 KB
gettext.py	19.47 KB
gettext.pyc	15.19 KB
gettext.pyo	15.19 KB
glob.py	2.86 KB
glob.pyc	2.83 KB
glob.pyo	2.83 KB
gzip.py	18.26 KB
gzip.pyc	14.72 KB
gzip.pyo	14.72 KB
hashlib.py	7.48 KB
hashlib.pyc	6.74 KB
hashlib.pyo	6.74 KB
heapq.py	17.76 KB
heapq.pyc	14.13 KB
heapq.pyo	14.13 KB
hmac.py	4.48 KB
hmac.pyc	4.44 KB
hmac.pyo	4.44 KB
hotshot	-
htmlentitydefs.py	17.63 KB
htmlentitydefs.pyc	6.22 KB
htmlentitydefs.pyo	6.22 KB
htmllib.py	12.57 KB
htmllib.pyc	19.83 KB
htmllib.pyo	19.83 KB
httplib.py	51.37 KB
httplib.pyc	37.54 KB
httplib.pyo	37.37 KB
idlelib	-
ihooks.py	18.54 KB
ihooks.pyc	20.87 KB
ihooks.pyo	20.87 KB
imaplib.py	47.34 KB
imaplib.pyc	44.45 KB
imaplib.pyo	41.8 KB
imghdr.py	3.46 KB
imghdr.pyc	4.73 KB
imghdr.pyo	4.73 KB
importlib	-
imputil.py	25.16 KB
imputil.pyc	15.26 KB
imputil.pyo	15.08 KB
inspect.py	41.47 KB
inspect.pyc	39.04 KB
inspect.pyo	39.04 KB
io.py	3.12 KB
io.pyc	3.4 KB
io.pyo	3.4 KB
json	-
keyword.py	1.95 KB
keyword.pyc	2.06 KB
keyword.pyo	2.06 KB
lib-dynload	-
lib-tk	-
lib2to3	-
linecache.py	3.87 KB
linecache.pyc	3.14 KB
linecache.pyo	3.14 KB
locale.py	87.33 KB
locale.pyc	48.77 KB
locale.pyo	48.77 KB
logging	-
macpath.py	6.11 KB
macpath.pyc	7.47 KB
macpath.pyo	7.47 KB
macurl2path.py	3.2 KB
macurl2path.pyc	2.71 KB
macurl2path.pyo	2.71 KB
mailbox.py	78.86 KB
mailbox.pyc	74.87 KB
mailbox.pyo	74.82 KB
mailcap.py	8.2 KB
mailcap.pyc	7.77 KB
mailcap.pyo	7.77 KB
markupbase.py	14.3 KB
markupbase.pyc	9.08 KB
markupbase.pyo	8.89 KB
md5.py	358 B
md5.pyc	378 B
md5.pyo	378 B
mhlib.py	32.65 KB
mhlib.pyc	33.01 KB
mhlib.pyo	33.01 KB
mimetools.py	7 KB
mimetools.pyc	8.03 KB
mimetools.pyo	8.03 KB
mimetypes.py	20.22 KB
mimetypes.pyc	17.86 KB
mimetypes.pyo	17.86 KB
mimify.py	14.67 KB
mimify.pyc	11.71 KB
mimify.pyo	11.71 KB
modulefinder.py	23.71 KB
modulefinder.pyc	18.27 KB
modulefinder.pyo	18.19 KB
multifile.py	4.71 KB
multifile.pyc	5.29 KB
multifile.pyo	5.25 KB
multiprocessing	-
mutex.py	1.83 KB
mutex.pyc	2.46 KB
mutex.pyo	2.46 KB
netrc.py	4.47 KB
netrc.pyc	3.83 KB
netrc.pyo	3.83 KB
new.py	610 B
new.pyc	862 B
new.pyo	862 B
nntplib.py	20.97 KB
nntplib.pyc	20.55 KB
nntplib.pyo	20.55 KB
ntpath.py	18.02 KB
ntpath.pyc	11.6 KB
ntpath.pyo	11.56 KB
nturl2path.py	2.32 KB
nturl2path.pyc	1.77 KB
nturl2path.pyo	1.77 KB
numbers.py	10.08 KB
numbers.pyc	13.68 KB
numbers.pyo	13.68 KB
opcode.py	5.35 KB
opcode.pyc	6 KB
opcode.pyo	6 KB
optparse.py	59.69 KB
optparse.pyc	52.78 KB
optparse.pyo	52.7 KB
os.py	25.17 KB
os.pyc	24.96 KB
os.pyo	24.96 KB
os2emxpath.py	4.5 KB
os2emxpath.pyc	4.39 KB
os2emxpath.pyo	4.39 KB
pdb.doc	7.73 KB
pdb.py	44.94 KB
pdb.pyc	42.59 KB
pdb.pyo	42.59 KB
pickle.py	44.09 KB
pickle.pyc	37.56 KB
pickle.pyo	37.37 KB
pickletools.py	72.79 KB
pickletools.pyc	55.77 KB
pickletools.pyo	54.95 KB
pipes.py	9.36 KB
pipes.pyc	9.09 KB
pipes.pyo	9.09 KB
pkgutil.py	19.87 KB
pkgutil.pyc	18.49 KB
pkgutil.pyo	18.49 KB
plat-linux2	-
platform.py	51.98 KB
platform.pyc	36.06 KB
platform.pyo	36.06 KB
plistlib.py	15.44 KB
plistlib.pyc	19.52 KB
plistlib.pyo	19.44 KB
popen2.py	8.22 KB
popen2.pyc	8.81 KB
popen2.pyo	8.77 KB
poplib.py	12.64 KB
poplib.pyc	13.16 KB
poplib.pyo	13.16 KB
posixfile.py	7.82 KB
posixfile.pyc	7.47 KB
posixfile.pyo	7.47 KB
posixpath.py	13.27 KB
posixpath.pyc	11.03 KB
posixpath.pyo	11.03 KB
pprint.py	11.73 KB
pprint.pyc	10.06 KB
pprint.pyo	9.89 KB
profile.py	22.25 KB
profile.pyc	16.07 KB
profile.pyo	15.83 KB
pstats.py	26.08 KB
pstats.pyc	24.43 KB
pstats.pyo	24.43 KB
pty.py	4.94 KB
pty.pyc	4.85 KB
pty.pyo	4.85 KB
py_compile.py	5.79 KB
py_compile.pyc	6.27 KB
py_compile.pyo	6.27 KB
pyclbr.py	13.07 KB
pyclbr.pyc	9.42 KB
pyclbr.pyo	9.42 KB
pydoc.py	91.12 KB
pydoc.pyc	88.35 KB
pydoc.pyo	88.29 KB
pydoc_data	-
quopri.py	6.81 KB
quopri.pyc	6.42 KB
quopri.pyo	6.42 KB
random.py	31.45 KB
random.pyc	24.99 KB
random.pyo	24.99 KB
re.py	12.66 KB
re.pyc	12.79 KB
re.pyo	12.79 KB
repr.py	4.2 KB
repr.pyc	5.26 KB
repr.pyo	5.26 KB
rexec.py	19.68 KB
rexec.pyc	23.58 KB
rexec.pyo	23.58 KB
rfc822.py	32.51 KB
rfc822.pyc	31.05 KB
rfc822.pyo	31.05 KB
rlcompleter.py	5.68 KB
rlcompleter.pyc	5.84 KB
rlcompleter.pyo	5.84 KB
robotparser.py	7.03 KB
robotparser.pyc	7.7 KB
robotparser.pyo	7.7 KB
runpy.py	10.45 KB
runpy.pyc	8.21 KB
runpy.pyo	8.21 KB
sched.py	4.97 KB
sched.pyc	4.88 KB
sched.pyo	4.88 KB
sets.py	18.6 KB
sets.pyc	16.5 KB
sets.pyo	16.5 KB
sgmllib.py	17.46 KB
sgmllib.pyc	15.07 KB
sgmllib.pyo	15.07 KB
sha.py	393 B
sha.pyc	421 B
sha.pyo	421 B
shelve.py	7.89 KB
shelve.pyc	10.03 KB
shelve.pyo	10.03 KB
shlex.py	10.88 KB
shlex.pyc	7.37 KB
shlex.pyo	7.37 KB
shutil.py	18.46 KB
shutil.pyc	18.1 KB
shutil.pyo	18.1 KB
site-packages	-
site.py	19.61 KB
site.pyc	19.11 KB
site.pyo	19.11 KB
smtpd.py	18.11 KB
smtpd.pyc	15.52 KB
smtpd.pyo	15.52 KB
smtplib.py	30.9 KB
smtplib.pyc	29.29 KB
smtplib.pyo	29.29 KB
sndhdr.py	5.83 KB
sndhdr.pyc	7.18 KB
sndhdr.pyo	7.18 KB
socket.py	20.03 KB
socket.pyc	15.73 KB
socket.pyo	15.64 KB
sqlite3	-
sre.py	384 B
sre.pyc	519 B
sre.pyo	519 B
sre_compile.py	15.99 KB
sre_compile.pyc	10.76 KB
sre_compile.pyo	10.65 KB
sre_constants.py	6.95 KB
sre_constants.pyc	5.97 KB
sre_constants.pyo	5.97 KB
sre_parse.py	26.84 KB
sre_parse.pyc	18.98 KB
sre_parse.pyo	18.98 KB
ssl.py	38.7 KB
ssl.pyc	32.05 KB
ssl.pyo	32.05 KB
stat.py	1.8 KB
stat.pyc	2.69 KB
stat.pyo	2.69 KB
statvfs.py	898 B
statvfs.pyc	620 B
statvfs.pyo	620 B
string.py	20.27 KB
string.pyc	19.54 KB
string.pyo	19.54 KB
stringold.py	12.16 KB
stringold.pyc	12.25 KB
stringold.pyo	12.25 KB
stringprep.py	13.21 KB
stringprep.pyc	14.15 KB
stringprep.pyo	14.08 KB
struct.py	82 B
struct.pyc	239 B
struct.pyo	239 B
subprocess.py	57.68 KB
subprocess.pyc	40.93 KB
subprocess.pyo	40.93 KB
sunau.py	16.15 KB
sunau.pyc	17.53 KB
sunau.pyo	17.53 KB
sunaudio.py	1.37 KB
sunaudio.pyc	1.94 KB
sunaudio.pyo	1.94 KB
symbol.py	2.01 KB
symbol.pyc	2.96 KB
symbol.pyo	2.96 KB
symtable.py	7.34 KB
symtable.pyc	11.59 KB
symtable.pyo	11.46 KB
sysconfig.py	21.88 KB
sysconfig.pyc	17.23 KB
sysconfig.pyo	17.23 KB
tabnanny.py	11.07 KB
tabnanny.pyc	8.05 KB
tabnanny.pyo	8.05 KB
tarfile.py	88.12 KB
tarfile.pyc	73.84 KB
tarfile.pyo	73.84 KB
telnetlib.py	26.18 KB
telnetlib.pyc	22.53 KB
telnetlib.pyo	22.53 KB
tempfile.py	17.91 KB
tempfile.pyc	19.35 KB
tempfile.pyo	19.35 KB
test	-
textwrap.py	16.64 KB
textwrap.pyc	11.62 KB
textwrap.pyo	11.53 KB
this.py	1002 B
this.pyc	1.19 KB
this.pyo	1.19 KB
threading.py	46.28 KB
threading.pyc	41.7 KB
threading.pyo	39.58 KB
timeit.py	11.82 KB
timeit.pyc	11.5 KB
timeit.pyo	11.5 KB
toaiff.py	3.07 KB
toaiff.pyc	3.03 KB
toaiff.pyo	3.03 KB
token.py	2.88 KB
token.pyc	3.73 KB
token.pyo	3.73 KB
tokenize.py	16.15 KB
tokenize.pyc	13.61 KB
tokenize.pyo	13.52 KB
trace.py	29.19 KB
trace.pyc	22.26 KB
trace.pyo	22.2 KB
traceback.py	10.99 KB
traceback.pyc	11.35 KB
traceback.pyo	11.35 KB
tty.py	879 B
tty.pyc	1.29 KB
tty.pyo	1.29 KB
types.py	1.99 KB
types.pyc	2.45 KB
types.pyo	2.45 KB
unittest	-
urllib.py	57.14 KB
urllib.pyc	49.1 KB
urllib.pyo	49 KB
urllib2.py	52.13 KB
urllib2.pyc	46.61 KB
urllib2.pyo	46.52 KB
urlparse.py	16.82 KB
urlparse.pyc	15.67 KB
urlparse.pyo	15.67 KB
user.py	1.59 KB
user.pyc	1.68 KB
user.pyo	1.68 KB
uu.py	6.4 KB
uu.pyc	4.21 KB
uu.pyo	4.21 KB
uuid.py	20.6 KB
uuid.pyc	20.68 KB
uuid.pyo	20.68 KB
warnings.py	13.71 KB
warnings.pyc	12.84 KB
warnings.pyo	12.02 KB
wave.py	17.67 KB
wave.pyc	19 KB
wave.pyo	18.94 KB
weakref.py	10.44 KB
weakref.pyc	13.72 KB
weakref.pyo	13.72 KB
webbrowser.py	22.68 KB
webbrowser.pyc	19.83 KB
webbrowser.pyo	19.78 KB
whichdb.py	3.3 KB
whichdb.pyc	2.19 KB
whichdb.pyo	2.19 KB
wsgiref	-
wsgiref.egg-info	187 B
xdrlib.py	5.43 KB
xdrlib.pyc	9.07 KB
xdrlib.pyo	9.07 KB
xml	-
xmllib.py	34.05 KB
xmllib.pyc	26.22 KB
xmllib.pyo	26.22 KB
xmlrpclib.py	50.78 KB
xmlrpclib.pyc	42.89 KB
xmlrpclib.pyo	42.71 KB
zipfile.py	56.45 KB
zipfile.pyc	40.33 KB
zipfile.pyo	40.33 KB

Edit: sre_compile.py

#
# Secret Labs' Regular Expression Engine
#
# convert template to internal format
#
# Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
#
# See the sre.py file for information on usage and redistribution.
#

"""Internal support module for sre"""

import _sre, sys
import sre_parse
from sre_constants import *
from _sre import MAXREPEAT

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

if _sre.CODESIZE == 2:
    MAXCODE = 65535
else:
    MAXCODE = 0xFFFFFFFFL

def _identityfunction(x):
    return x

_LITERAL_CODES = set([LITERAL, NOT_LITERAL])
_REPEATING_CODES = set([REPEAT, MIN_REPEAT, MAX_REPEAT])
_SUCCESS_CODES = set([SUCCESS, FAILURE])
_ASSERT_CODES = set([ASSERT, ASSERT_NOT])

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
    for op, av in pattern:
        if op in LITERAL_CODES:
            if flags & SRE_FLAG_IGNORECASE:
                emit(OPCODES[OP_IGNORE[op]])
                emit(_sre.getlower(av, flags))
            else:
                emit(OPCODES[op])
                emit(av)
        elif op is IN:
            if flags & SRE_FLAG_IGNORECASE:
                emit(OPCODES[OP_IGNORE[op]])
                def fixup(literal, flags=flags):
                    return _sre.getlower(literal, flags)
            else:
                emit(OPCODES[op])
                fixup = _identityfunction
            skip = _len(code); emit(0)
            _compile_charset(av, flags, code, fixup)
            code[skip] = _len(code) - skip
        elif op is ANY:
            if flags & SRE_FLAG_DOTALL:
                emit(OPCODES[ANY_ALL])
            else:
                emit(OPCODES[ANY])
        elif op in REPEATING_CODES:
            if flags & SRE_FLAG_TEMPLATE:
                raise error, "internal: unsupported template operator"
                emit(OPCODES[REPEAT])
                skip = _len(code); emit(0)
                emit(av[0])
                emit(av[1])
                _compile(code, av[2], flags)
                emit(OPCODES[SUCCESS])
                code[skip] = _len(code) - skip
            elif _simple(av) and op is not REPEAT:
                if op is MAX_REPEAT:
                    emit(OPCODES[REPEAT_ONE])
                else:
                    emit(OPCODES[MIN_REPEAT_ONE])
                skip = _len(code); emit(0)
                emit(av[0])
                emit(av[1])
                _compile(code, av[2], flags)
                emit(OPCODES[SUCCESS])
                code[skip] = _len(code) - skip
            else:
                emit(OPCODES[REPEAT])
                skip = _len(code); emit(0)
                emit(av[0])
                emit(av[1])
                _compile(code, av[2], flags)
                code[skip] = _len(code) - skip
                if op is MAX_REPEAT:
                    emit(OPCODES[MAX_UNTIL])
                else:
                    emit(OPCODES[MIN_UNTIL])
        elif op is SUBPATTERN:
            if av[0]:
                emit(OPCODES[MARK])
                emit((av[0]-1)*2)
            # _compile_info(code, av[1], flags)
            _compile(code, av[1], flags)
            if av[0]:
                emit(OPCODES[MARK])
                emit((av[0]-1)*2+1)
        elif op in SUCCESS_CODES:
            emit(OPCODES[op])
        elif op in ASSERT_CODES:
            emit(OPCODES[op])
            skip = _len(code); emit(0)
            if av[0] >= 0:
                emit(0) # look ahead
            else:
                lo, hi = av[1].getwidth()
                if lo != hi:
                    raise error, "look-behind requires fixed-width pattern"
                emit(lo) # look behind
            _compile(code, av[1], flags)
            emit(OPCODES[SUCCESS])
            code[skip] = _len(code) - skip
        elif op is CALL:
            emit(OPCODES[op])
            skip = _len(code); emit(0)
            _compile(code, av, flags)
            emit(OPCODES[SUCCESS])
            code[skip] = _len(code) - skip
        elif op is AT:
            emit(OPCODES[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(ATCODES[av])
        elif op is BRANCH:
            emit(OPCODES[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(OPCODES[JUMP])
                tailappend(_len(code)); emit(0)
                code[skip] = _len(code) - skip
            emit(0) # end of branch
            for tail in tail:
                code[tail] = _len(code) - tail
        elif op is CATEGORY:
            emit(OPCODES[op])
            if flags & SRE_FLAG_LOCALE:
                av = CH_LOCALE[av]
            elif flags & SRE_FLAG_UNICODE:
                av = CH_UNICODE[av]
            emit(CHCODES[av])
        elif op is GROUPREF:
            if flags & SRE_FLAG_IGNORECASE:
                emit(OPCODES[OP_IGNORE[op]])
            else:
                emit(OPCODES[op])
            emit(av-1)
        elif op is GROUPREF_EXISTS:
            emit(OPCODES[op])
            emit(av[0]-1)
            skipyes = _len(code); emit(0)
            _compile(code, av[1], flags)
            if av[2]:
                emit(OPCODES[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 ValueError, ("unsupported operand type", op)

def _compile_charset(charset, flags, code, fixup=None):
    # compile charset subprogram
    emit = code.append
    if fixup is None:
        fixup = _identityfunction
    for op, av in _optimize_charset(charset, fixup):
        emit(OPCODES[op])
        if op is NEGATE:
            pass
        elif op is LITERAL:
            emit(fixup(av))
        elif op is RANGE:
            emit(fixup(av[0]))
            emit(fixup(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(CHCODES[CH_LOCALE[av]])
            elif flags & SRE_FLAG_UNICODE:
                emit(CHCODES[CH_UNICODE[av]])
            else:
                emit(CHCODES[av])
        else:
            raise error, "internal: unsupported set operator"
    emit(OPCODES[FAILURE])

def _optimize_charset(charset, fixup):
    # internal: optimize character set
    out = []
    outappend = out.append
    charmap = [0]*256
    try:
        for op, av in charset:
            if op is NEGATE:
                outappend((op, av))
            elif op is LITERAL:
                charmap[fixup(av)] = 1
            elif op is RANGE:
                for i in range(fixup(av[0]), fixup(av[1])+1):
                    charmap[i] = 1
            elif op is CATEGORY:
                # XXX: could append to charmap tail
                return charset # cannot compress
    except IndexError:
        # character set contains unicode characters
        return _optimize_unicode(charset, fixup)
    # compress character map
    i = p = n = 0
    runs = []
    runsappend = runs.append
    for c in charmap:
        if c:
            if n == 0:
                p = i
            n = n + 1
        elif n:
            runsappend((p, n))
            n = 0
        i = i + 1
    if n:
        runsappend((p, n))
    if len(runs) <= 2:
        # use literal/range
        for p, n in runs:
            if n == 1:
                outappend((LITERAL, p))
            else:
                outappend((RANGE, (p, p+n-1)))
        if len(out) < len(charset):
            return out
    else:
        # use bitmap
        data = _mk_bitmap(charmap)
        outappend((CHARSET, data))
        return out
    return charset

def _mk_bitmap(bits):
    data = []
    dataappend = data.append
    if _sre.CODESIZE == 2:
        start = (1, 0)
    else:
        start = (1L, 0L)
    m, v = start
    for c in bits:
        if c:
            v = v + m
        m = m + m
        if m > MAXCODE:
            dataappend(v)
            m, v = start
    return data

# 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 16-bit word sequence, consisting of one word for
# the number of different chunks, a sequence of 256 bytes (128 words)
# of chunk numbers indexed by their original chunk position, and a
# sequence of chunks (16 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).

# In UCS-4 mode, the BIGCHARSET opcode still supports only subsets
# of the basic multilingual plane; an efficient representation
# for all of UTF-16 has not yet been developed. This means,
# in particular, that negated charsets cannot be represented as
# bigcharsets.

def _optimize_unicode(charset, fixup):
    try:
        import array
    except ImportError:
        return charset
    charmap = [0]*65536
    negate = 0
    try:
        for op, av in charset:
            if op is NEGATE:
                negate = 1
            elif op is LITERAL:
                charmap[fixup(av)] = 1
            elif op is RANGE:
                for i in xrange(fixup(av[0]), fixup(av[1])+1):
                    charmap[i] = 1
            elif op is CATEGORY:
                # XXX: could expand category
                return charset # cannot compress
    except IndexError:
        # non-BMP characters
        return charset
    if negate:
        if sys.maxunicode != 65535:
            # XXX: negation does not work with big charsets
            return charset
        for i in xrange(65536):
            charmap[i] = not charmap[i]
    comps = {}
    mapping = [0]*256
    block = 0
    data = []
    for i in xrange(256):
        chunk = tuple(charmap[i*256:(i+1)*256])
        new = comps.setdefault(chunk, block)
        mapping[i] = new
        if new == block:
            block = block + 1
            data = data + _mk_bitmap(chunk)
    header = [block]
    if _sre.CODESIZE == 2:
        code = 'H'
    else:
        code = 'I'
    # Convert block indices to byte array of 256 bytes
    mapping = array.array('b', mapping).tostring()
    # Convert byte array to word array
    mapping = array.array(code, mapping)
    assert mapping.itemsize == _sre.CODESIZE
    header = header + mapping.tolist()
    data[0:0] = header
    return [(BIGCHARSET, data)]

def _simple(av):
    # check if av is a "simple" operator
    lo, hi = av[2].getwidth()
    return lo == hi == 1 and av[2][0][0] != SUBPATTERN

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 lo == 0:
        return # not worth it
    # look for a literal prefix
    prefix = []
    prefixappend = prefix.append
    prefix_skip = 0
    charset = [] # not used
    charsetappend = charset.append
    if not (flags & SRE_FLAG_IGNORECASE):
        # look for literal prefix
        for op, av in pattern.data:
            if op is LITERAL:
                if len(prefix) == prefix_skip:
                    prefix_skip = prefix_skip + 1
                prefixappend(av)
            elif op is SUBPATTERN and len(av[1]) == 1:
                op, av = av[1][0]
                if op is LITERAL:
                    prefixappend(av)
                else:
                    break
            else:
                break
        # if no prefix, look for charset prefix
        if not prefix and pattern.data:
            op, av = pattern.data[0]
            if op is SUBPATTERN and av[1]:
                op, av = av[1][0]
                if op is LITERAL:
                    charsetappend((op, av))
                elif op is BRANCH:
                    c = []
                    cappend = c.append
                    for p in av[1]:
                        if not p:
                            break
                        op, av = p[0]
                        if op is LITERAL:
                            cappend((op, av))
                        else:
                            break
                    else:
                        charset = c
            elif op is BRANCH:
                c = []
                cappend = c.append
                for p in av[1]:
                    if not p:
                        break
                    op, av = p[0]
                    if op is LITERAL:
                        cappend((op, av))
                    else:
                        break
                else:
                    charset = c
            elif op is IN:
                charset = av
##     if prefix:
##         print "*** PREFIX", prefix, prefix_skip
##     if charset:
##         print "*** CHARSET", charset
    # add an info block
    emit = code.append
    emit(OPCODES[INFO])
    skip = len(code); emit(0)
    # literal flag
    mask = 0
    if prefix:
        mask = SRE_INFO_PREFIX
        if len(prefix) == prefix_skip == len(pattern.data):
            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]
    if hi < MAXCODE:
        emit(hi)
    else:
        emit(0)
    # add literal prefix
    if prefix:
        emit(len(prefix)) # length
        emit(prefix_skip) # skip
        code.extend(prefix)
        # generate overlap table
        table = [-1] + ([0]*len(prefix))
        for i in xrange(len(prefix)):
            table[i+1] = table[i]+1
            while table[i+1] > 0 and prefix[i] != prefix[table[i+1]-1]:
                table[i+1] = table[table[i+1]-1]+1
        code.extend(table[1:]) # don't store first entry
    elif charset:
        _compile_charset(charset, flags, code)
    code[skip] = len(code) - skip

try:
    unicode
except NameError:
    STRING_TYPES = (type(""),)
else:
    STRING_TYPES = (type(""), type(unicode("")))

def isstring(obj):
    for tp in STRING_TYPES:
        if isinstance(obj, tp):
            return 1
    return 0

def _code(p, flags):

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

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

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

code.append(OPCODES[SUCCESS])

return code

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

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

code = _code(p, flags)

# print code

# XXX: <fl> get rid of this limitation!
    if p.pattern.groups > 100:
        raise AssertionError(
            "sorry, but this version only supports 100 named groups"
            )

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

return _sre.compile(
        pattern, flags | p.pattern.flags, code,
        p.pattern.groups-1,
        groupindex, indexgroup
        )