Mercurial Repositories > APIs / file diff

diff -r c1b714f5a750 -r 9fc07b8c55b8 APIs/Python2/Python-2.4.api
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/APIs/Python2/Python-2.4.api	Sun Jun 09 17:21:45 2013 +0200
@@ -0,0 +1,7663 @@
+ArithmeticError(??)
+AssertionError(??)
+AttributeError(??)
+BaseHTTPServer.BaseHTTPRequestHandler(??)
+BaseHTTPServer.DEFAULT_ERROR_MESSAGE
+BaseHTTPServer.HTTPServer(??)
+BaseHTTPServer.SocketServer
+BaseHTTPServer.mimetools
+BaseHTTPServer.socket
+BaseHTTPServer.sys
+BaseHTTPServer.test(??)
+BaseHTTPServer.time
+Bastion.Bastion(??)
+Bastion.BastionClass(??)
+Bastion.MethodType
+CGIHTTPServer.BaseHTTPServer
+CGIHTTPServer.CGIHTTPRequestHandler(??)
+CGIHTTPServer.SimpleHTTPServer
+CGIHTTPServer.executable(??)
+CGIHTTPServer.nobody
+CGIHTTPServer.nobody_uid(??)
+CGIHTTPServer.os
+CGIHTTPServer.select
+CGIHTTPServer.sys
+CGIHTTPServer.test(??)
+CGIHTTPServer.urllib
+ConfigParser.ConfigParser(??)
+ConfigParser.DEFAULTSECT
+ConfigParser.DuplicateSectionError(??)
+ConfigParser.Error(??)
+ConfigParser.InterpolationDepthError(??)
+ConfigParser.InterpolationError(??)
+ConfigParser.InterpolationMissingOptionError(??)
+ConfigParser.InterpolationSyntaxError(??)
+ConfigParser.MAX_INTERPOLATION_DEPTH
+ConfigParser.MissingSectionHeaderError(??)
+ConfigParser.NoOptionError(??)
+ConfigParser.NoSectionError(??)
+ConfigParser.ParsingError(??)
+ConfigParser.RawConfigParser(??)
+ConfigParser.SafeConfigParser(??)
+ConfigParser.re
+Cookie.BaseCookie
+Cookie.Cookie
+Cookie.CookieError(??)
+Cookie.Morsel
+Cookie.SerialCookie
+Cookie.SimpleCookie
+Cookie.SmartCookie
+Cookie.dumps(obj, protocol=0) -- Return a string containing an object in pickle format.
+Cookie.loads(string) -- Load a pickle from the given string
+Cookie.re
+Cookie.string
+Cookie.warnings
+DeprecationWarning(??)
+DocXMLRPCServer.CGIXMLRPCRequestHandler(??)
+DocXMLRPCServer.DocCGIXMLRPCRequestHandler(??)
+DocXMLRPCServer.DocXMLRPCRequestHandler(??)
+DocXMLRPCServer.DocXMLRPCServer(??)
+DocXMLRPCServer.ServerHTMLDoc(??)
+DocXMLRPCServer.SimpleXMLRPCRequestHandler(??)
+DocXMLRPCServer.SimpleXMLRPCServer(??)
+DocXMLRPCServer.XMLRPCDocGenerator(??)
+DocXMLRPCServer.inspect
+DocXMLRPCServer.pydoc
+DocXMLRPCServer.re
+DocXMLRPCServer.resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d
+DocXMLRPCServer.sys
+DocXMLRPCServer.types
+EOFError(??)
+Ellipsis
+EnvironmentError(??)
+Exception(??)
+False
+FloatingPointError(??)
+FutureWarning(??)
+HTMLParser.HTMLParseError(??)
+HTMLParser.HTMLParser(??)
+HTMLParser.attrfind
+HTMLParser.charref
+HTMLParser.commentclose
+HTMLParser.endendtag
+HTMLParser.endtagfind
+HTMLParser.entityref
+HTMLParser.incomplete
+HTMLParser.interesting_cdata
+HTMLParser.interesting_normal
+HTMLParser.locatestarttagend
+HTMLParser.markupbase
+HTMLParser.piclose
+HTMLParser.re
+HTMLParser.starttagopen
+HTMLParser.tagfind
+IOError(??)
+ImportError(??)
+IndentationError(??)
+IndexError(??)
+KeyError(??)
+KeyboardInterrupt(??)
+LookupError(??)
+MemoryError(??)
+MimeWriter.MimeWriter(??)
+MimeWriter.mimetools
+NameError(??)
+None
+NotImplemented
+NotImplementedError(??)
+OSError(??)
+OverflowError(??)
+OverflowWarning(??)
+PendingDeprecationWarning(??)
+Queue.Empty(??)
+Queue.Full(??)
+Queue.Queue(??)
+Queue.deque(iterable) --> deque object
+ReferenceError(??)
+RuntimeError(??)
+RuntimeWarning(??)
+SimpleHTTPServer.BaseHTTPServer
+SimpleHTTPServer.SimpleHTTPRequestHandler(??)
+SimpleHTTPServer.StringIO(??)
+SimpleHTTPServer.cgi
+SimpleHTTPServer.mimetypes
+SimpleHTTPServer.os
+SimpleHTTPServer.posixpath
+SimpleHTTPServer.shutil
+SimpleHTTPServer.test(??)
+SimpleHTTPServer.urllib
+SimpleHTTPServer.urlparse
+SimpleXMLRPCServer.BaseHTTPServer
+SimpleXMLRPCServer.CGIXMLRPCRequestHandler(??)
+SimpleXMLRPCServer.Fault(??)
+SimpleXMLRPCServer.SimpleXMLRPCDispatcher(??)
+SimpleXMLRPCServer.SimpleXMLRPCRequestHandler(??)
+SimpleXMLRPCServer.SimpleXMLRPCServer(??)
+SimpleXMLRPCServer.SocketServer
+SimpleXMLRPCServer.list_public_methods(??)
+SimpleXMLRPCServer.os
+SimpleXMLRPCServer.remove_duplicates([2,2,2,1,3,3]) => [3,1,2]
+SimpleXMLRPCServer.resolve_dotted_attribute(a, 'b.c.d') => a.b.c.d
+SimpleXMLRPCServer.sys
+SimpleXMLRPCServer.xmlrpclib
+SocketServer.BaseRequestHandler(??)
+SocketServer.BaseServer(??)
+SocketServer.DatagramRequestHandler(??)
+SocketServer.ForkingMixIn(??)
+SocketServer.ForkingTCPServer(??)
+SocketServer.ForkingUDPServer(??)
+SocketServer.StreamRequestHandler(??)
+SocketServer.TCPServer(??)
+SocketServer.ThreadingMixIn(??)
+SocketServer.ThreadingTCPServer(??)
+SocketServer.ThreadingUDPServer(??)
+SocketServer.ThreadingUnixDatagramServer(??)
+SocketServer.ThreadingUnixStreamServer(??)
+SocketServer.UDPServer(??)
+SocketServer.UnixDatagramServer(??)
+SocketServer.UnixStreamServer(??)
+SocketServer.os
+SocketServer.socket
+SocketServer.sys
+StandardError(??)
+StopIteration(??)
+StringIO.EINVAL
+StringIO.StringIO(??)
+StringIO.test(??)
+SyntaxError(??)
+SyntaxWarning(??)
+SystemError(??)
+SystemExit(??)
+TabError(??)
+True
+TypeError(??)
+UnboundLocalError(??)
+UnicodeDecodeError(??)
+UnicodeEncodeError(??)
+UnicodeError(??)
+UnicodeTranslateError(??)
+UserDict.DictMixin(??)
+UserDict.IterableUserDict(??)
+UserDict.UserDict(??)
+UserList.UserList(??)
+UserString.MutableString(??)
+UserString.StringTypes
+UserString.UserString(??)
+UserString.sys
+UserWarning(??)
+ValueError(??)
+Warning(??)
+ZeroDivisionError(??)
+abs(number) -> number
+aifc.Aifc_read(??)
+aifc.Aifc_write(??)
+aifc.Chunk(??)
+aifc.Error(??)
+aifc.open(??)
+aifc.openfp(??)
+aifc.struct
+anydbm.error
+anydbm.open(??)
+apply(object[, args[, kwargs]]) -> value
+array.ArrayType
+array.array(typecode [, initializer]) -> array
+asynchat.async_chat(??)
+asynchat.asyncore
+asynchat.deque(iterable) --> deque object
+asynchat.fifo(??)
+asynchat.find_prefix_at_end(??)
+asynchat.simple_producer(??)
+asynchat.socket
+asyncore.EALREADY
+asyncore.ECONNRESET
+asyncore.EINPROGRESS
+asyncore.EINTR
+asyncore.EISCONN
+asyncore.ENOTCONN
+asyncore.ESHUTDOWN
+asyncore.EWOULDBLOCK
+asyncore.ExitNow(??)
+asyncore.close_all(??)
+asyncore.compact_traceback(??)
+asyncore.dispatcher(??)
+asyncore.dispatcher_with_send(??)
+asyncore.errorcode
+asyncore.exceptions
+asyncore.fcntl
+asyncore.file_dispatcher(??)
+asyncore.file_wrapper(??)
+asyncore.loop(??)
+asyncore.os
+asyncore.poll(??)
+asyncore.poll2(??)
+asyncore.poll3(??)
+asyncore.read(??)
+asyncore.readwrite(??)
+asyncore.select
+asyncore.socket
+asyncore.socket_map
+asyncore.sys
+asyncore.time
+asyncore.write(??)
+atexit.register(??)
+atexit.sys
+audiodev.AudioDev(??)
+audiodev.Play_Audio_sgi(??)
+audiodev.Play_Audio_sun(??)
+audiodev.error(??)
+audiodev.test(??)
+audioop.add
+audioop.adpcm2lin
+audioop.avg
+audioop.avgpp
+audioop.bias
+audioop.cross
+audioop.error(??)
+audioop.findfactor
+audioop.findfit
+audioop.findmax
+audioop.getsample
+audioop.lin2adpcm
+audioop.lin2lin
+audioop.lin2ulaw
+audioop.max
+audioop.maxpp
+audioop.minmax
+audioop.mul
+audioop.ratecv
+audioop.reverse
+audioop.rms
+audioop.tomono
+audioop.tostereo
+audioop.ulaw2lin
+base64.EMPTYSTRING
+base64.MAXBINSIZE
+base64.MAXLINESIZE
+base64.b16decode(??)
+base64.b16encode(??)
+base64.b32decode(??)
+base64.b32encode(??)
+base64.b64decode(??)
+base64.b64encode(??)
+base64.binascii
+base64.decode(??)
+base64.decodestring(??)
+base64.encode(??)
+base64.encodestring(??)
+base64.k
+base64.re
+base64.standard_b64decode(??)
+base64.standard_b64encode(??)
+base64.struct
+base64.test(??)
+base64.test1(??)
+base64.urlsafe_b64decode(??)
+base64.urlsafe_b64encode(??)
+base64.v
+basestring
+bdb.Bdb(??)
+bdb.BdbQuit(??)
+bdb.Breakpoint(??)
+bdb.Tdb(??)
+bdb.bar(??)
+bdb.checkfuncname(??)
+bdb.effective(??)
+bdb.foo(??)
+bdb.os
+bdb.set_trace(??)
+bdb.sys
+bdb.test(??)
+bdb.types
+binascii.Error(??)
+binascii.Incomplete(??)
+binascii.a2b_base64
+binascii.a2b_hex(hexstr) -> s; Binary data of hexadecimal representation.
+binascii.a2b_hqx
+binascii.a2b_qp
+binascii.a2b_uu
+binascii.b2a_base64
+binascii.b2a_hex(data) -> s; Hexadecimal representation of binary data.
+binascii.b2a_hqx
+binascii.b2a_qp(data, quotetabs=0, istext=1, header=0) -> s;
+binascii.b2a_uu
+binascii.crc32
+binascii.crc_hqx
+binascii.hexlify
+binascii.rlecode_hqx
+binascii.rledecode_hqx
+binascii.unhexlify
+binhex.BinHex(??)
+binhex.Error(??)
+binhex.FInfo(??)
+binhex.HexBin(??)
+binhex.LINELEN
+binhex.REASONABLY_LARGE
+binhex.RUNCHAR
+binhex.binascii
+binhex.binhex(??)
+binhex.getfileinfo(??)
+binhex.hexbin(??)
+binhex.openrsrc(??)
+binhex.os
+binhex.struct
+binhex.sys
+bisect.bisect
+bisect.bisect_left(a, x[, lo[, hi]]) -> index
+bisect.bisect_right(a, x[, lo[, hi]]) -> index
+bisect.insort
+bisect.insort_left(a, x[, lo[, hi]])
+bisect.insort_right(a, x[, lo[, hi]])
+bool(x) -> bool
+bsddb.UserDict
+bsddb.btopen(??)
+bsddb.db
+bsddb.db.DB
+bsddb.db.DBAccessError(??)
+bsddb.db.DBAgainError(??)
+bsddb.db.DBBusyError(??)
+bsddb.db.DBCursorClosedError(??)
+bsddb.db.DBEnv
+bsddb.db.DBError(??)
+bsddb.db.DBFileExistsError(??)
+bsddb.db.DBInvalidArgError(??)
+bsddb.db.DBKeyEmptyError(??)
+bsddb.db.DBKeyExistError(??)
+bsddb.db.DBLockDeadlockError(??)
+bsddb.db.DBLockNotGrantedError(??)
+bsddb.db.DBNoMemoryError(??)
+bsddb.db.DBNoServerError(??)
+bsddb.db.DBNoServerHomeError(??)
+bsddb.db.DBNoServerIDError(??)
+bsddb.db.DBNoSpaceError(??)
+bsddb.db.DBNoSuchFileError(??)
+bsddb.db.DBNotFoundError(??)
+bsddb.db.DBOldVersionError(??)
+bsddb.db.DBPageNotFoundError(??)
+bsddb.db.DBPermissionsError(??)
+bsddb.db.DBRunRecoveryError(??)
+bsddb.db.DBSecondaryBadError(??)
+bsddb.db.DBVerifyBadError(??)
+bsddb.db.DB_AFTER
+bsddb.db.DB_AGGRESSIVE
+bsddb.db.DB_APPEND
+bsddb.db.DB_ARCH_ABS
+bsddb.db.DB_ARCH_DATA
+bsddb.db.DB_ARCH_LOG
+bsddb.db.DB_AUTO_COMMIT
+bsddb.db.DB_BEFORE
+bsddb.db.DB_BTREE
+bsddb.db.DB_CACHED_COUNTS
+bsddb.db.DB_CDB_ALLDB
+bsddb.db.DB_CHECKPOINT
+bsddb.db.DB_CHKSUM
+bsddb.db.DB_CONSUME
+bsddb.db.DB_CONSUME_WAIT
+bsddb.db.DB_CREATE
+bsddb.db.DB_CURRENT
+bsddb.db.DB_DIRECT_DB
+bsddb.db.DB_DIRECT_LOG
+bsddb.db.DB_DIRTY_READ
+bsddb.db.DB_DONOTINDEX
+bsddb.db.DB_DUP
+bsddb.db.DB_DUPSORT
+bsddb.db.DB_ENCRYPT
+bsddb.db.DB_ENCRYPT_AES
+bsddb.db.DB_EXCL
+bsddb.db.DB_EXTENT
+bsddb.db.DB_FAST_STAT
+bsddb.db.DB_FCNTL_LOCKING
+bsddb.db.DB_FIRST
+bsddb.db.DB_FLUSH
+bsddb.db.DB_FORCE
+bsddb.db.DB_GET_BOTH
+bsddb.db.DB_GET_RECNO
+bsddb.db.DB_HASH
+bsddb.db.DB_INCOMPLETE
+bsddb.db.DB_INIT_CDB
+bsddb.db.DB_INIT_LOCK
+bsddb.db.DB_INIT_LOG
+bsddb.db.DB_INIT_MPOOL
+bsddb.db.DB_INIT_REP
+bsddb.db.DB_INIT_TXN
+bsddb.db.DB_JOINENV
+bsddb.db.DB_JOIN_ITEM
+bsddb.db.DB_JOIN_NOSORT
+bsddb.db.DB_KEYEMPTY
+bsddb.db.DB_KEYEXIST
+bsddb.db.DB_KEYFIRST
+bsddb.db.DB_KEYLAST
+bsddb.db.DB_LAST
+bsddb.db.DB_LOCKDOWN
+bsddb.db.DB_LOCK_CONFLICT
+bsddb.db.DB_LOCK_DEADLOCK
+bsddb.db.DB_LOCK_DEFAULT
+bsddb.db.DB_LOCK_DIRTY
+bsddb.db.DB_LOCK_DUMP
+bsddb.db.DB_LOCK_GET
+bsddb.db.DB_LOCK_INHERIT
+bsddb.db.DB_LOCK_IREAD
+bsddb.db.DB_LOCK_IWR
+bsddb.db.DB_LOCK_IWRITE
+bsddb.db.DB_LOCK_MAXLOCKS
+bsddb.db.DB_LOCK_MINLOCKS
+bsddb.db.DB_LOCK_MINWRITE
+bsddb.db.DB_LOCK_NG
+bsddb.db.DB_LOCK_NORUN
+bsddb.db.DB_LOCK_NOTGRANTED
+bsddb.db.DB_LOCK_NOWAIT
+bsddb.db.DB_LOCK_OLDEST
+bsddb.db.DB_LOCK_PUT
+bsddb.db.DB_LOCK_PUT_ALL
+bsddb.db.DB_LOCK_PUT_OBJ
+bsddb.db.DB_LOCK_RANDOM
+bsddb.db.DB_LOCK_READ
+bsddb.db.DB_LOCK_RECORD
+bsddb.db.DB_LOCK_SWITCH
+bsddb.db.DB_LOCK_UPGRADE
+bsddb.db.DB_LOCK_UPGRADE_WRITE
+bsddb.db.DB_LOCK_WAIT
+bsddb.db.DB_LOCK_WRITE
+bsddb.db.DB_LOCK_WWRITE
+bsddb.db.DB_LOCK_YOUNGEST
+bsddb.db.DB_LOG_AUTOREMOVE
+bsddb.db.DB_LSTAT_ABORTED
+bsddb.db.DB_LSTAT_ERR
+bsddb.db.DB_LSTAT_FREE
+bsddb.db.DB_LSTAT_HELD
+bsddb.db.DB_LSTAT_PENDING
+bsddb.db.DB_LSTAT_WAITING
+bsddb.db.DB_MAX_PAGES
+bsddb.db.DB_MAX_RECORDS
+bsddb.db.DB_MULTIPLE
+bsddb.db.DB_MULTIPLE_KEY
+bsddb.db.DB_NEXT
+bsddb.db.DB_NEXT_DUP
+bsddb.db.DB_NEXT_NODUP
+bsddb.db.DB_NODUPDATA
+bsddb.db.DB_NOLOCKING
+bsddb.db.DB_NOMMAP
+bsddb.db.DB_NOORDERCHK
+bsddb.db.DB_NOOVERWRITE
+bsddb.db.DB_NOPANIC
+bsddb.db.DB_NOSERVER
+bsddb.db.DB_NOSERVER_HOME
+bsddb.db.DB_NOSERVER_ID
+bsddb.db.DB_NOSYNC
+bsddb.db.DB_NOTFOUND
+bsddb.db.DB_ODDFILESIZE
+bsddb.db.DB_OLD_VERSION
+bsddb.db.DB_OPFLAGS_MASK
+bsddb.db.DB_ORDERCHKONLY
+bsddb.db.DB_PAGE_NOTFOUND
+bsddb.db.DB_PANIC_ENVIRONMENT
+bsddb.db.DB_POSITION
+bsddb.db.DB_PREV
+bsddb.db.DB_PREV_NODUP
+bsddb.db.DB_PRIVATE
+bsddb.db.DB_PR_PAGE
+bsddb.db.DB_PR_RECOVERYTEST
+bsddb.db.DB_QUEUE
+bsddb.db.DB_RDONLY
+bsddb.db.DB_RDWRMASTER
+bsddb.db.DB_RECNO
+bsddb.db.DB_RECNUM
+bsddb.db.DB_RECORDCOUNT
+bsddb.db.DB_RECOVER
+bsddb.db.DB_RECOVER_FATAL
+bsddb.db.DB_REGION_INIT
+bsddb.db.DB_RENUMBER
+bsddb.db.DB_REVSPLITOFF
+bsddb.db.DB_RMW
+bsddb.db.DB_RPCCLIENT
+bsddb.db.DB_RUNRECOVERY
+bsddb.db.DB_SALVAGE
+bsddb.db.DB_SECONDARY_BAD
+bsddb.db.DB_SET
+bsddb.db.DB_SET_LOCK_TIMEOUT
+bsddb.db.DB_SET_RANGE
+bsddb.db.DB_SET_RECNO
+bsddb.db.DB_SET_TXN_TIMEOUT
+bsddb.db.DB_SNAPSHOT
+bsddb.db.DB_STAT_CLEAR
+bsddb.db.DB_SYSTEM_MEM
+bsddb.db.DB_THREAD
+bsddb.db.DB_TIME_NOTGRANTED
+bsddb.db.DB_TRUNCATE
+bsddb.db.DB_TXN_NOSYNC
+bsddb.db.DB_TXN_NOT_DURABLE
+bsddb.db.DB_TXN_NOWAIT
+bsddb.db.DB_TXN_SYNC
+bsddb.db.DB_TXN_WRITE_NOSYNC
+bsddb.db.DB_UNKNOWN
+bsddb.db.DB_UPGRADE
+bsddb.db.DB_USE_ENVIRON
+bsddb.db.DB_USE_ENVIRON_ROOT
+bsddb.db.DB_VERIFY
+bsddb.db.DB_VERIFY_BAD
+bsddb.db.DB_VERSION_MAJOR
+bsddb.db.DB_VERSION_MINOR
+bsddb.db.DB_VERSION_PATCH
+bsddb.db.DB_VERSION_STRING
+bsddb.db.DB_WRITECURSOR
+bsddb.db.DB_XA_CREATE
+bsddb.db.DB_YIELDCPU
+bsddb.db.EACCES
+bsddb.db.EAGAIN
+bsddb.db.EBUSY
+bsddb.db.EEXIST
+bsddb.db.EINVAL
+bsddb.db.ENOENT
+bsddb.db.ENOMEM
+bsddb.db.ENOSPC
+bsddb.db.EPERM
+bsddb.db.cvsid
+bsddb.db.version
+bsddb.dbobj
+bsddb.dbobj.DB(??)
+bsddb.dbobj.DBEnv(??)
+bsddb.dbobj.DictMixin(??)
+bsddb.dbobj.db
+bsddb.dbrecio
+bsddb.dbrecio.DBRecIO(??)
+bsddb.dbrecio.errno
+bsddb.dbrecio.string
+bsddb.dbshelve
+bsddb.dbshelve.DBShelf(??)
+bsddb.dbshelve.DBShelfCursor(??)
+bsddb.dbshelve.DictMixin(??)
+bsddb.dbshelve.cPickle
+bsddb.dbshelve.db
+bsddb.dbshelve.open(??)
+bsddb.dbtables
+bsddb.dbtables.Cond(??)
+bsddb.dbtables.DB
+bsddb.dbtables.DBAccessError(??)
+bsddb.dbtables.DBAgainError(??)
+bsddb.dbtables.DBBusyError(??)
+bsddb.dbtables.DBCursorClosedError(??)
+bsddb.dbtables.DBEnv
+bsddb.dbtables.DBError(??)
+bsddb.dbtables.DBFileExistsError(??)
+bsddb.dbtables.DBInvalidArgError(??)
+bsddb.dbtables.DBKeyEmptyError(??)
+bsddb.dbtables.DBKeyExistError(??)
+bsddb.dbtables.DBLockDeadlockError(??)
+bsddb.dbtables.DBLockNotGrantedError(??)
+bsddb.dbtables.DBNoMemoryError(??)
+bsddb.dbtables.DBNoServerError(??)
+bsddb.dbtables.DBNoServerHomeError(??)
+bsddb.dbtables.DBNoServerIDError(??)
+bsddb.dbtables.DBNoSpaceError(??)
+bsddb.dbtables.DBNoSuchFileError(??)
+bsddb.dbtables.DBNotFoundError(??)
+bsddb.dbtables.DBOldVersionError(??)
+bsddb.dbtables.DBPageNotFoundError(??)
+bsddb.dbtables.DBPermissionsError(??)
+bsddb.dbtables.DBRunRecoveryError(??)
+bsddb.dbtables.DBSecondaryBadError(??)
+bsddb.dbtables.DBVerifyBadError(??)
+bsddb.dbtables.DB_AFTER
+bsddb.dbtables.DB_AGGRESSIVE
+bsddb.dbtables.DB_APPEND
+bsddb.dbtables.DB_ARCH_ABS
+bsddb.dbtables.DB_ARCH_DATA
+bsddb.dbtables.DB_ARCH_LOG
+bsddb.dbtables.DB_AUTO_COMMIT
+bsddb.dbtables.DB_BEFORE
+bsddb.dbtables.DB_BTREE
+bsddb.dbtables.DB_CACHED_COUNTS
+bsddb.dbtables.DB_CDB_ALLDB
+bsddb.dbtables.DB_CHECKPOINT
+bsddb.dbtables.DB_CHKSUM
+bsddb.dbtables.DB_CONSUME
+bsddb.dbtables.DB_CONSUME_WAIT
+bsddb.dbtables.DB_CREATE
+bsddb.dbtables.DB_CURRENT
+bsddb.dbtables.DB_DIRECT_DB
+bsddb.dbtables.DB_DIRECT_LOG
+bsddb.dbtables.DB_DIRTY_READ
+bsddb.dbtables.DB_DONOTINDEX
+bsddb.dbtables.DB_DUP
+bsddb.dbtables.DB_DUPSORT
+bsddb.dbtables.DB_ENCRYPT
+bsddb.dbtables.DB_ENCRYPT_AES
+bsddb.dbtables.DB_EXCL
+bsddb.dbtables.DB_EXTENT
+bsddb.dbtables.DB_FAST_STAT
+bsddb.dbtables.DB_FCNTL_LOCKING
+bsddb.dbtables.DB_FIRST
+bsddb.dbtables.DB_FLUSH
+bsddb.dbtables.DB_FORCE
+bsddb.dbtables.DB_GET_BOTH
+bsddb.dbtables.DB_GET_RECNO
+bsddb.dbtables.DB_HASH
+bsddb.dbtables.DB_INCOMPLETE
+bsddb.dbtables.DB_INIT_CDB
+bsddb.dbtables.DB_INIT_LOCK
+bsddb.dbtables.DB_INIT_LOG
+bsddb.dbtables.DB_INIT_MPOOL
+bsddb.dbtables.DB_INIT_REP
+bsddb.dbtables.DB_INIT_TXN
+bsddb.dbtables.DB_JOINENV
+bsddb.dbtables.DB_JOIN_ITEM
+bsddb.dbtables.DB_JOIN_NOSORT
+bsddb.dbtables.DB_KEYEMPTY
+bsddb.dbtables.DB_KEYEXIST
+bsddb.dbtables.DB_KEYFIRST
+bsddb.dbtables.DB_KEYLAST
+bsddb.dbtables.DB_LAST
+bsddb.dbtables.DB_LOCKDOWN
+bsddb.dbtables.DB_LOCK_CONFLICT
+bsddb.dbtables.DB_LOCK_DEADLOCK
+bsddb.dbtables.DB_LOCK_DEFAULT
+bsddb.dbtables.DB_LOCK_DIRTY
+bsddb.dbtables.DB_LOCK_DUMP
+bsddb.dbtables.DB_LOCK_GET
+bsddb.dbtables.DB_LOCK_INHERIT
+bsddb.dbtables.DB_LOCK_IREAD
+bsddb.dbtables.DB_LOCK_IWR
+bsddb.dbtables.DB_LOCK_IWRITE
+bsddb.dbtables.DB_LOCK_MAXLOCKS
+bsddb.dbtables.DB_LOCK_MINLOCKS
+bsddb.dbtables.DB_LOCK_MINWRITE
+bsddb.dbtables.DB_LOCK_NG
+bsddb.dbtables.DB_LOCK_NORUN
+bsddb.dbtables.DB_LOCK_NOTGRANTED
+bsddb.dbtables.DB_LOCK_NOWAIT
+bsddb.dbtables.DB_LOCK_OLDEST
+bsddb.dbtables.DB_LOCK_PUT
+bsddb.dbtables.DB_LOCK_PUT_ALL
+bsddb.dbtables.DB_LOCK_PUT_OBJ
+bsddb.dbtables.DB_LOCK_RANDOM
+bsddb.dbtables.DB_LOCK_READ
+bsddb.dbtables.DB_LOCK_RECORD
+bsddb.dbtables.DB_LOCK_SWITCH
+bsddb.dbtables.DB_LOCK_UPGRADE
+bsddb.dbtables.DB_LOCK_UPGRADE_WRITE
+bsddb.dbtables.DB_LOCK_WAIT
+bsddb.dbtables.DB_LOCK_WRITE
+bsddb.dbtables.DB_LOCK_WWRITE
+bsddb.dbtables.DB_LOCK_YOUNGEST
+bsddb.dbtables.DB_LOG_AUTOREMOVE
+bsddb.dbtables.DB_LSTAT_ABORTED
+bsddb.dbtables.DB_LSTAT_ERR
+bsddb.dbtables.DB_LSTAT_FREE
+bsddb.dbtables.DB_LSTAT_HELD
+bsddb.dbtables.DB_LSTAT_PENDING
+bsddb.dbtables.DB_LSTAT_WAITING
+bsddb.dbtables.DB_MAX_PAGES
+bsddb.dbtables.DB_MAX_RECORDS
+bsddb.dbtables.DB_MULTIPLE
+bsddb.dbtables.DB_MULTIPLE_KEY
+bsddb.dbtables.DB_NEXT
+bsddb.dbtables.DB_NEXT_DUP
+bsddb.dbtables.DB_NEXT_NODUP
+bsddb.dbtables.DB_NODUPDATA
+bsddb.dbtables.DB_NOLOCKING
+bsddb.dbtables.DB_NOMMAP
+bsddb.dbtables.DB_NOORDERCHK
+bsddb.dbtables.DB_NOOVERWRITE
+bsddb.dbtables.DB_NOPANIC
+bsddb.dbtables.DB_NOSERVER
+bsddb.dbtables.DB_NOSERVER_HOME
+bsddb.dbtables.DB_NOSERVER_ID
+bsddb.dbtables.DB_NOSYNC
+bsddb.dbtables.DB_NOTFOUND
+bsddb.dbtables.DB_ODDFILESIZE
+bsddb.dbtables.DB_OLD_VERSION
+bsddb.dbtables.DB_OPFLAGS_MASK
+bsddb.dbtables.DB_ORDERCHKONLY
+bsddb.dbtables.DB_PAGE_NOTFOUND
+bsddb.dbtables.DB_PANIC_ENVIRONMENT
+bsddb.dbtables.DB_POSITION
+bsddb.dbtables.DB_PREV
+bsddb.dbtables.DB_PREV_NODUP
+bsddb.dbtables.DB_PRIVATE
+bsddb.dbtables.DB_PR_PAGE
+bsddb.dbtables.DB_PR_RECOVERYTEST
+bsddb.dbtables.DB_QUEUE
+bsddb.dbtables.DB_RDONLY
+bsddb.dbtables.DB_RDWRMASTER
+bsddb.dbtables.DB_RECNO
+bsddb.dbtables.DB_RECNUM
+bsddb.dbtables.DB_RECORDCOUNT
+bsddb.dbtables.DB_RECOVER
+bsddb.dbtables.DB_RECOVER_FATAL
+bsddb.dbtables.DB_REGION_INIT
+bsddb.dbtables.DB_RENUMBER
+bsddb.dbtables.DB_REVSPLITOFF
+bsddb.dbtables.DB_RMW
+bsddb.dbtables.DB_RPCCLIENT
+bsddb.dbtables.DB_RUNRECOVERY
+bsddb.dbtables.DB_SALVAGE
+bsddb.dbtables.DB_SECONDARY_BAD
+bsddb.dbtables.DB_SET
+bsddb.dbtables.DB_SET_LOCK_TIMEOUT
+bsddb.dbtables.DB_SET_RANGE
+bsddb.dbtables.DB_SET_RECNO
+bsddb.dbtables.DB_SET_TXN_TIMEOUT
+bsddb.dbtables.DB_SNAPSHOT
+bsddb.dbtables.DB_STAT_CLEAR
+bsddb.dbtables.DB_SYSTEM_MEM
+bsddb.dbtables.DB_THREAD
+bsddb.dbtables.DB_TIME_NOTGRANTED
+bsddb.dbtables.DB_TRUNCATE
+bsddb.dbtables.DB_TXN_NOSYNC
+bsddb.dbtables.DB_TXN_NOT_DURABLE
+bsddb.dbtables.DB_TXN_NOWAIT
+bsddb.dbtables.DB_TXN_SYNC
+bsddb.dbtables.DB_TXN_WRITE_NOSYNC
+bsddb.dbtables.DB_UNKNOWN
+bsddb.dbtables.DB_UPGRADE
+bsddb.dbtables.DB_USE_ENVIRON
+bsddb.dbtables.DB_USE_ENVIRON_ROOT
+bsddb.dbtables.DB_VERIFY
+bsddb.dbtables.DB_VERIFY_BAD
+bsddb.dbtables.DB_VERSION_MAJOR
+bsddb.dbtables.DB_VERSION_MINOR
+bsddb.dbtables.DB_VERSION_PATCH
+bsddb.dbtables.DB_VERSION_STRING
+bsddb.dbtables.DB_WRITECURSOR
+bsddb.dbtables.DB_XA_CREATE
+bsddb.dbtables.DB_YIELDCPU
+bsddb.dbtables.EACCES
+bsddb.dbtables.EAGAIN
+bsddb.dbtables.EBUSY
+bsddb.dbtables.EEXIST
+bsddb.dbtables.EINVAL
+bsddb.dbtables.ENOENT
+bsddb.dbtables.ENOMEM
+bsddb.dbtables.ENOSPC
+bsddb.dbtables.EPERM
+bsddb.dbtables.ExactCond(??)
+bsddb.dbtables.LikeCond(??)
+bsddb.dbtables.ListType
+bsddb.dbtables.PostfixCond(??)
+bsddb.dbtables.PrefixCond(??)
+bsddb.dbtables.StringType
+bsddb.dbtables.TableAlreadyExists(??)
+bsddb.dbtables.TableDBError(??)
+bsddb.dbtables.bsdTableDB(??)
+bsddb.dbtables.contains_metastrings(??)
+bsddb.dbtables.copy
+bsddb.dbtables.cvsid
+bsddb.dbtables.pickle
+bsddb.dbtables.random
+bsddb.dbtables.re
+bsddb.dbtables.sys
+bsddb.dbtables.version
+bsddb.dbtables.xdrlib
+bsddb.dbutils
+bsddb.dbutils.DeadlockWrap(function, *_args, **_kwargs) - automatically retries
+bsddb.dbutils.db
+bsddb.error(??)
+bsddb.hashopen(??)
+bsddb.os
+bsddb.ref
+bsddb.rnopen(??)
+bsddb.sys
+buffer(object [, offset[, size]])
+bz2.BZ2Compressor([compresslevel=9]) -> compressor object
+bz2.BZ2Decompressor() -> decompressor object
+bz2.BZ2File(name [, mode='r', buffering=0, compresslevel=9]) -> file object
+bz2.compress(data [, compresslevel=9]) -> string
+bz2.decompress(data) -> decompressed data
+cPickle.BadPickleGet(??)
+cPickle.HIGHEST_PROTOCOL
+cPickle.PickleError(??)
+cPickle.Pickler(file, protocol=0) -- Create a pickler.
+cPickle.PicklingError(??)
+cPickle.UnpickleableError(??)
+cPickle.Unpickler(file) -- Create an unpickler.
+cPickle.UnpicklingError(??)
+cPickle.compatible_formats
+cPickle.dump(obj, file, protocol=0) -- Write an object in pickle format to the given file.
+cPickle.dumps(obj, protocol=0) -- Return a string containing an object in pickle format.
+cPickle.format_version
+cPickle.load(file) -- Load a pickle from the given file
+cPickle.loads(string) -- Load a pickle from the given string
+cStringIO.InputType
+cStringIO.OutputType
+cStringIO.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+cStringIO.cStringIO_CAPI
+calendar.EPOCH
+calendar.FRIDAY
+calendar.February
+calendar.January
+calendar.MONDAY
+calendar.SATURDAY
+calendar.SUNDAY
+calendar.THURSDAY
+calendar.TUESDAY
+calendar.WEDNESDAY
+calendar.calendar(??)
+calendar.datetime
+calendar.day_abbr
+calendar.day_name
+calendar.error(??)
+calendar.firstweekday(??)
+calendar.format3c(??)
+calendar.format3cstring(??)
+calendar.isleap(??)
+calendar.leapdays(??)
+calendar.mdays
+calendar.month(??)
+calendar.month_abbr
+calendar.month_name
+calendar.monthcalendar(??)
+calendar.monthrange(??)
+calendar.prcal(??)
+calendar.prmonth(??)
+calendar.prweek(??)
+calendar.setfirstweekday(??)
+calendar.timegm(??)
+calendar.week(??)
+calendar.weekday(??)
+calendar.weekheader(??)
+callable(object) -> bool
+cgi.FieldStorage(??)
+cgi.FormContent(??)
+cgi.FormContentDict(??)
+cgi.InterpFormContentDict(??)
+cgi.MiniFieldStorage(??)
+cgi.StringIO(??)
+cgi.SvFormContentDict(??)
+cgi.UserDict
+cgi.dolog(??)
+cgi.escape(??)
+cgi.initlog(??)
+cgi.log(??)
+cgi.logfile
+cgi.logfp
+cgi.maxlen
+cgi.mimetools
+cgi.nolog(??)
+cgi.os
+cgi.parse(??)
+cgi.parse_header(??)
+cgi.parse_multipart(??)
+cgi.parse_qs(??)
+cgi.parse_qsl(??)
+cgi.print_arguments(??)
+cgi.print_directory(??)
+cgi.print_environ(??)
+cgi.print_environ_usage(??)
+cgi.print_exception(??)
+cgi.print_form(??)
+cgi.rfc822
+cgi.sys
+cgi.test(??)
+cgi.urllib
+cgi.valid_boundary(??)
+cgitb.Hook(??)
+cgitb.enable(??)
+cgitb.grey(??)
+cgitb.handler
+cgitb.html(??)
+cgitb.lookup(??)
+cgitb.reset(??)
+cgitb.scanvars(??)
+cgitb.small(??)
+cgitb.strong(??)
+cgitb.sys
+cgitb.text(??)
+chr(i) -> character
+chunk.Chunk(??)
+classmethod(function) -> method
+cmath.acos(x)
+cmath.acosh(x)
+cmath.asin(x)
+cmath.asinh(x)
+cmath.atan(x)
+cmath.atanh(x)
+cmath.cos(x)
+cmath.cosh(x)
+cmath.e
+cmath.exp(x)
+cmath.log(x[, base]) -> the logarithm of x to the given base.
+cmath.log10(x)
+cmath.pi
+cmath.sin(x)
+cmath.sinh(x)
+cmath.sqrt(x)
+cmath.tan(x)
+cmath.tanh(x)
+cmd.Cmd(??)
+cmd.IDENTCHARS
+cmd.PROMPT
+cmd.string
+cmp(x, y) -> integer
+code.CommandCompiler(??)
+code.InteractiveConsole(??)
+code.InteractiveInterpreter(??)
+code.compile_command(??)
+code.interact(??)
+code.softspace(??)
+code.sys
+code.traceback
+codecs.BOM
+codecs.BOM32_BE
+codecs.BOM32_LE
+codecs.BOM64_BE
+codecs.BOM64_LE
+codecs.BOM_BE
+codecs.BOM_LE
+codecs.BOM_UTF16
+codecs.BOM_UTF16_BE
+codecs.BOM_UTF16_LE
+codecs.BOM_UTF32
+codecs.BOM_UTF32_BE
+codecs.BOM_UTF32_LE
+codecs.BOM_UTF8
+codecs.Codec(??)
+codecs.EncodedFile(??)
+codecs.StreamReader(??)
+codecs.StreamReaderWriter(??)
+codecs.StreamRecoder(??)
+codecs.StreamWriter(??)
+codecs.ascii_decode
+codecs.ascii_encode
+codecs.backslashreplace_errors
+codecs.charbuffer_encode
+codecs.charmap_decode
+codecs.charmap_encode
+codecs.decode(obj, [encoding[,errors]]) -> object
+codecs.encode(obj, [encoding[,errors]]) -> object
+codecs.escape_decode
+codecs.escape_encode
+codecs.getdecoder(??)
+codecs.getencoder(??)
+codecs.getreader(??)
+codecs.getwriter(??)
+codecs.ignore_errors
+codecs.latin_1_decode
+codecs.latin_1_encode
+codecs.lookup(encoding) -> (encoder, decoder, stream_reader, stream_writer)
+codecs.lookup_error(errors) -> handler
+codecs.make_encoding_map(??)
+codecs.make_identity_dict(rng) -> dict
+codecs.open(??)
+codecs.raw_unicode_escape_decode
+codecs.raw_unicode_escape_encode
+codecs.readbuffer_encode
+codecs.register(search_function)
+codecs.register_error(errors, handler)
+codecs.replace_errors
+codecs.strict_errors
+codecs.sys
+codecs.unicode_escape_decode
+codecs.unicode_escape_encode
+codecs.unicode_internal_decode
+codecs.unicode_internal_encode
+codecs.utf_16_be_decode
+codecs.utf_16_be_encode
+codecs.utf_16_decode
+codecs.utf_16_encode
+codecs.utf_16_ex_decode
+codecs.utf_16_le_decode
+codecs.utf_16_le_encode
+codecs.utf_7_decode
+codecs.utf_7_encode
+codecs.utf_8_decode
+codecs.utf_8_encode
+codecs.xmlcharrefreplace_errors
+codeop.CommandCompiler(??)
+codeop.Compile(??)
+codeop.PyCF_DONT_IMPLY_DEDENT
+codeop.compile_command(??)
+codeop.fname
+coerce(x, y) -> (x1, y1)
+collections.deque(iterable) --> deque object
+colorsys.ONE_SIXTH
+colorsys.ONE_THIRD
+colorsys.TWO_THIRD
+colorsys.hls_to_rgb(??)
+colorsys.hsv_to_rgb(??)
+colorsys.rgb_to_hls(??)
+colorsys.rgb_to_hsv(??)
+colorsys.rgb_to_yiq(??)
+colorsys.yiq_to_rgb(??)
+commands.getoutput(??)
+commands.getstatus(??)
+commands.getstatusoutput(??)
+commands.mk2arg(??)
+commands.mkarg(??)
+compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
+compileall.compile_dir(??)
+compileall.compile_path(??)
+compileall.main(??)
+compileall.os
+compileall.py_compile
+compileall.sys
+compiler.ast
+compiler.ast.Add(??)
+compiler.ast.And(??)
+compiler.ast.AssAttr(??)
+compiler.ast.AssList(??)
+compiler.ast.AssName(??)
+compiler.ast.AssTuple(??)
+compiler.ast.Assert(??)
+compiler.ast.Assign(??)
+compiler.ast.AugAssign(??)
+compiler.ast.Backquote(??)
+compiler.ast.Bitand(??)
+compiler.ast.Bitor(??)
+compiler.ast.Bitxor(??)
+compiler.ast.Break(??)
+compiler.ast.CO_VARARGS
+compiler.ast.CO_VARKEYWORDS
+compiler.ast.CallFunc(??)
+compiler.ast.Class(??)
+compiler.ast.Compare(??)
+compiler.ast.Const(??)
+compiler.ast.Continue(??)
+compiler.ast.Decorators(??)
+compiler.ast.Dict(??)
+compiler.ast.Discard(??)
+compiler.ast.Div(??)
+compiler.ast.Ellipsis(??)
+compiler.ast.EmptyNode(??)
+compiler.ast.Exec(??)
+compiler.ast.Expression(??)
+compiler.ast.FloorDiv(??)
+compiler.ast.For(??)
+compiler.ast.From(??)
+compiler.ast.Function(??)
+compiler.ast.GenExpr(??)
+compiler.ast.GenExprFor(??)
+compiler.ast.GenExprIf(??)
+compiler.ast.GenExprInner(??)
+compiler.ast.Getattr(??)
+compiler.ast.Global(??)
+compiler.ast.If(??)
+compiler.ast.Import(??)
+compiler.ast.Invert(??)
+compiler.ast.Keyword(??)
+compiler.ast.Lambda(??)
+compiler.ast.LeftShift(??)
+compiler.ast.List(??)
+compiler.ast.ListComp(??)
+compiler.ast.ListCompFor(??)
+compiler.ast.ListCompIf(??)
+compiler.ast.Mod(??)
+compiler.ast.Module(??)
+compiler.ast.Mul(??)
+compiler.ast.Name(??)
+compiler.ast.Node(??)
+compiler.ast.Not(??)
+compiler.ast.Or(??)
+compiler.ast.Pass(??)
+compiler.ast.Power(??)
+compiler.ast.Print(??)
+compiler.ast.Printnl(??)
+compiler.ast.Raise(??)
+compiler.ast.Return(??)
+compiler.ast.RightShift(??)
+compiler.ast.Slice(??)
+compiler.ast.Sliceobj(??)
+compiler.ast.Stmt(??)
+compiler.ast.Sub(??)
+compiler.ast.Subscript(??)
+compiler.ast.TryExcept(??)
+compiler.ast.TryFinally(??)
+compiler.ast.Tuple(??)
+compiler.ast.UnaryAdd(??)
+compiler.ast.UnarySub(??)
+compiler.ast.While(??)
+compiler.ast.Yield(??)
+compiler.ast.flatten(??)
+compiler.ast.flatten_nodes(??)
+compiler.ast.name
+compiler.ast.nodes
+compiler.ast.obj(??)
+compiler.compile(??)
+compiler.compileFile(??)
+compiler.consts
+compiler.consts.CO_FUTURE_DIVISION
+compiler.consts.CO_GENERATOR
+compiler.consts.CO_GENERATOR_ALLOWED
+compiler.consts.CO_NESTED
+compiler.consts.CO_NEWLOCALS
+compiler.consts.CO_OPTIMIZED
+compiler.consts.CO_VARARGS
+compiler.consts.CO_VARKEYWORDS
+compiler.consts.OP_APPLY
+compiler.consts.OP_ASSIGN
+compiler.consts.OP_DELETE
+compiler.consts.SC_CELL
+compiler.consts.SC_FREE
+compiler.consts.SC_GLOBAL
+compiler.consts.SC_LOCAL
+compiler.consts.SC_UNKNOWN
+compiler.future
+compiler.future.BadFutureParser(??)
+compiler.future.FutureParser(??)
+compiler.future.ast
+compiler.future.find_futures(??)
+compiler.future.is_future(??)
+compiler.future.walk(??)
+compiler.misc
+compiler.misc.MANGLE_LEN
+compiler.misc.Set(??)
+compiler.misc.Stack(??)
+compiler.misc.flatten(??)
+compiler.misc.mangle(??)
+compiler.misc.set_filename(??)
+compiler.misc.types
+compiler.parse(??)
+compiler.parseFile(??)
+compiler.pyassem
+compiler.pyassem.Block(??)
+compiler.pyassem.CONV
+compiler.pyassem.CO_NEWLOCALS
+compiler.pyassem.CO_OPTIMIZED
+compiler.pyassem.CO_VARARGS
+compiler.pyassem.CO_VARKEYWORDS
+compiler.pyassem.DONE
+compiler.pyassem.FLAT
+compiler.pyassem.FlowGraph(??)
+compiler.pyassem.LineAddrTable(??)
+compiler.pyassem.PyFlowGraph(??)
+compiler.pyassem.RAW
+compiler.pyassem.StackDepthTracker(??)
+compiler.pyassem.TupleArg(??)
+compiler.pyassem.dfs_postorder(??)
+compiler.pyassem.dis
+compiler.pyassem.findDepth
+compiler.pyassem.getArgCount(??)
+compiler.pyassem.isJump(??)
+compiler.pyassem.misc
+compiler.pyassem.new
+compiler.pyassem.sys
+compiler.pyassem.twobyte(??)
+compiler.pyassem.types
+compiler.pycodegen
+compiler.pycodegen.AbstractClassCode(??)
+compiler.pycodegen.AbstractCompileMode(??)
+compiler.pycodegen.AbstractFunctionCode(??)
+compiler.pycodegen.AugGetattr(??)
+compiler.pycodegen.AugName(??)
+compiler.pycodegen.AugSlice(??)
+compiler.pycodegen.AugSubscript(??)
+compiler.pycodegen.CO_FUTURE_DIVISION
+compiler.pycodegen.CO_GENERATOR
+compiler.pycodegen.CO_GENERATOR_ALLOWED
+compiler.pycodegen.CO_NESTED
+compiler.pycodegen.CO_NEWLOCALS
+compiler.pycodegen.CO_VARARGS
+compiler.pycodegen.CO_VARKEYWORDS
+compiler.pycodegen.ClassCodeGenerator(??)
+compiler.pycodegen.CodeGenerator(??)
+compiler.pycodegen.Delegator(??)
+compiler.pycodegen.END_FINALLY
+compiler.pycodegen.EXCEPT
+compiler.pycodegen.Expression(??)
+compiler.pycodegen.ExpressionCodeGenerator(??)
+compiler.pycodegen.FunctionCodeGenerator(??)
+compiler.pycodegen.GenExprCodeGenerator(??)
+compiler.pycodegen.Interactive(??)
+compiler.pycodegen.InteractiveCodeGenerator(??)
+compiler.pycodegen.LOOP
+compiler.pycodegen.LocalNameFinder(??)
+compiler.pycodegen.Module(??)
+compiler.pycodegen.ModuleCodeGenerator(??)
+compiler.pycodegen.NestedScopeMixin(??)
+compiler.pycodegen.OpFinder(??)
+compiler.pycodegen.SC_CELL
+compiler.pycodegen.SC_FREE
+compiler.pycodegen.SC_GLOBAL
+compiler.pycodegen.SC_LOCAL
+compiler.pycodegen.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+compiler.pycodegen.TRY_FINALLY
+compiler.pycodegen.TupleArg(??)
+compiler.pycodegen.VERSION
+compiler.pycodegen.ast
+compiler.pycodegen.callfunc_opcode_info
+compiler.pycodegen.compile(??)
+compiler.pycodegen.compileFile(??)
+compiler.pycodegen.findOp(??)
+compiler.pycodegen.future
+compiler.pycodegen.generateArgList(??)
+compiler.pycodegen.imp
+compiler.pycodegen.is_constant_false(??)
+compiler.pycodegen.marshal
+compiler.pycodegen.misc
+compiler.pycodegen.os
+compiler.pycodegen.parse(??)
+compiler.pycodegen.pyassem
+compiler.pycodegen.struct
+compiler.pycodegen.symbols
+compiler.pycodegen.syntax
+compiler.pycodegen.sys
+compiler.pycodegen.types
+compiler.pycodegen.walk(??)
+compiler.pycodegen.wrap_aug(??)
+compiler.pycodegen.wrapper
+compiler.symbols
+compiler.symbols.ClassScope(??)
+compiler.symbols.FunctionScope(??)
+compiler.symbols.GenExprScope(??)
+compiler.symbols.LambdaScope(??)
+compiler.symbols.MANGLE_LEN
+compiler.symbols.ModuleScope(??)
+compiler.symbols.SC_CELL
+compiler.symbols.SC_FREE
+compiler.symbols.SC_GLOBAL
+compiler.symbols.SC_LOCAL
+compiler.symbols.SC_UNKNOWN
+compiler.symbols.Scope(??)
+compiler.symbols.SymbolVisitor(??)
+compiler.symbols.ast
+compiler.symbols.list_eq(??)
+compiler.symbols.mangle(??)
+compiler.symbols.sort(??)
+compiler.symbols.sys
+compiler.symbols.types
+compiler.syntax
+compiler.syntax.SyntaxErrorChecker(??)
+compiler.syntax.ast
+compiler.syntax.check(??)
+compiler.syntax.walk(??)
+compiler.transformer
+compiler.transformer.Add(??)
+compiler.transformer.And(??)
+compiler.transformer.AssAttr(??)
+compiler.transformer.AssList(??)
+compiler.transformer.AssName(??)
+compiler.transformer.AssTuple(??)
+compiler.transformer.Assert(??)
+compiler.transformer.Assign(??)
+compiler.transformer.AugAssign(??)
+compiler.transformer.Backquote(??)
+compiler.transformer.Bitand(??)
+compiler.transformer.Bitor(??)
+compiler.transformer.Bitxor(??)
+compiler.transformer.Break(??)
+compiler.transformer.CO_VARARGS
+compiler.transformer.CO_VARKEYWORDS
+compiler.transformer.CallFunc(??)
+compiler.transformer.Class(??)
+compiler.transformer.Compare(??)
+compiler.transformer.Const(??)
+compiler.transformer.Continue(??)
+compiler.transformer.Decorators(??)
+compiler.transformer.Dict(??)
+compiler.transformer.Discard(??)
+compiler.transformer.Div(??)
+compiler.transformer.Ellipsis(??)
+compiler.transformer.EmptyNode(??)
+compiler.transformer.Exec(??)
+compiler.transformer.Expression(??)
+compiler.transformer.FloorDiv(??)
+compiler.transformer.For(??)
+compiler.transformer.From(??)
+compiler.transformer.Function(??)
+compiler.transformer.GenExpr(??)
+compiler.transformer.GenExprFor(??)
+compiler.transformer.GenExprIf(??)
+compiler.transformer.GenExprInner(??)
+compiler.transformer.Getattr(??)
+compiler.transformer.Global(??)
+compiler.transformer.If(??)
+compiler.transformer.Import(??)
+compiler.transformer.Invert(??)
+compiler.transformer.Keyword(??)
+compiler.transformer.Lambda(??)
+compiler.transformer.LeftShift(??)
+compiler.transformer.List(??)
+compiler.transformer.ListComp(??)
+compiler.transformer.ListCompFor(??)
+compiler.transformer.ListCompIf(??)
+compiler.transformer.Mod(??)
+compiler.transformer.Module(??)
+compiler.transformer.Mul(??)
+compiler.transformer.Name(??)
+compiler.transformer.Node(??)
+compiler.transformer.Not(??)
+compiler.transformer.OP_APPLY
+compiler.transformer.OP_ASSIGN
+compiler.transformer.OP_DELETE
+compiler.transformer.Or(??)
+compiler.transformer.Pass(??)
+compiler.transformer.Power(??)
+compiler.transformer.Print(??)
+compiler.transformer.Printnl(??)
+compiler.transformer.Raise(??)
+compiler.transformer.Return(??)
+compiler.transformer.RightShift(??)
+compiler.transformer.Slice(??)
+compiler.transformer.Sliceobj(??)
+compiler.transformer.Stmt(??)
+compiler.transformer.Sub(??)
+compiler.transformer.Subscript(??)
+compiler.transformer.Transformer(??)
+compiler.transformer.TryExcept(??)
+compiler.transformer.TryFinally(??)
+compiler.transformer.Tuple(??)
+compiler.transformer.UnaryAdd(??)
+compiler.transformer.UnarySub(??)
+compiler.transformer.WalkerError(??)
+compiler.transformer.While(??)
+compiler.transformer.Yield(??)
+compiler.transformer.asList(??)
+compiler.transformer.debug_tree(??)
+compiler.transformer.extractLineNo(??)
+compiler.transformer.flatten(??)
+compiler.transformer.flatten_nodes(??)
+compiler.transformer.k
+compiler.transformer.name
+compiler.transformer.nodes
+compiler.transformer.obj(??)
+compiler.transformer.parse(??)
+compiler.transformer.parseFile(??)
+compiler.transformer.parser
+compiler.transformer.symbol
+compiler.transformer.sys
+compiler.transformer.token
+compiler.transformer.types
+compiler.transformer.v
+compiler.visitor
+compiler.visitor.ASTVisitor(??)
+compiler.visitor.ExampleASTVisitor(??)
+compiler.visitor.ast
+compiler.visitor.dumpNode(??)
+compiler.visitor.walk(??)
+compiler.walk(??)
+complex(real[, imag]) -> complex number
+cookielib.Absent(??)
+cookielib.Cookie(??)
+cookielib.CookieJar(??)
+cookielib.CookiePolicy(??)
+cookielib.DAYS
+cookielib.DEFAULT_HTTP_PORT
+cookielib.DefaultCookiePolicy(??)
+cookielib.EPOCH_YEAR
+cookielib.ESCAPED_CHAR_RE
+cookielib.FileCookieJar(??)
+cookielib.HEADER_ESCAPE_RE
+cookielib.HEADER_JOIN_ESCAPE_RE
+cookielib.HEADER_QUOTED_VALUE_RE
+cookielib.HEADER_TOKEN_RE
+cookielib.HEADER_VALUE_RE
+cookielib.HTTP_PATH_SAFE
+cookielib.IPV4_RE
+cookielib.ISO_DATE_RE
+cookielib.LOOSE_HTTP_DATE_RE
+cookielib.LWPCookieJar(??)
+cookielib.LoadError(??)
+cookielib.MISSING_FILENAME_TEXT
+cookielib.MONTHS
+cookielib.MONTHS_LOWER
+cookielib.MozillaCookieJar(??)
+cookielib.STRICT_DATE_RE
+cookielib.StringTypes
+cookielib.TIMEZONE_RE
+cookielib.UTC_ZONES
+cookielib.WEEKDAY_RE
+cookielib.copy
+cookielib.cut_port_re
+cookielib.debug
+cookielib.deepvalues(??)
+cookielib.domain_match(??)
+cookielib.eff_request_host(??)
+cookielib.escape_path(??)
+cookielib.http2time(??)
+cookielib.httplib
+cookielib.is_HDN(??)
+cookielib.is_third_party(??)
+cookielib.iso2time(??)
+cookielib.join_header_words(??)
+cookielib.liberal_is_HDN(??)
+cookielib.logging
+cookielib.lwp_cookie_str(??)
+cookielib.month
+cookielib.offset_from_tz_string(??)
+cookielib.parse_ns_headers(??)
+cookielib.re
+cookielib.reach(??)
+cookielib.request_host(??)
+cookielib.request_path(??)
+cookielib.request_port(??)
+cookielib.reraise_unmasked_exceptions(??)
+cookielib.split_header_words(??)
+cookielib.sys
+cookielib.time
+cookielib.time2isoz(??)
+cookielib.time2netscape(??)
+cookielib.timegm(??)
+cookielib.unmatched(??)
+cookielib.uppercase_escaped_char(??)
+cookielib.urllib
+cookielib.urlparse
+cookielib.user_domain_match(??)
+cookielib.vals_sorted_by_key(??)
+copy.Error(??)
+copy.PyStringMap
+copy.copy(??)
+copy.deepcopy(??)
+copy.dispatch_table
+copy.error(??)
+copy.inspect
+copy.name
+copy.t
+copy_reg.add_extension(??)
+copy_reg.clear_extension_cache(??)
+copy_reg.constructor(??)
+copy_reg.dispatch_table
+copy_reg.pickle(??)
+copy_reg.pickle_complex(??)
+copy_reg.remove_extension(??)
+copyright
+credits
+crypt.crypt(word, salt) -> string
+csv.Dialect(??)
+csv.DictReader(??)
+csv.DictWriter(??)
+csv.Error(??)
+csv.QUOTE_ALL
+csv.QUOTE_MINIMAL
+csv.QUOTE_NONE
+csv.QUOTE_NONNUMERIC
+csv.Sniffer(??)
+csv.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+csv.excel(??)
+csv.excel_tab(??)
+csv.get_dialect
+csv.list_dialects
+csv.re
+csv.reader
+csv.register_dialect
+csv.unregister_dialect
+csv.writer
+curses.ALL_MOUSE_EVENTS
+curses.A_ALTCHARSET
+curses.A_ATTRIBUTES
+curses.A_BLINK
+curses.A_BOLD
+curses.A_CHARTEXT
+curses.A_COLOR
+curses.A_DIM
+curses.A_HORIZONTAL
+curses.A_INVIS
+curses.A_LEFT
+curses.A_LOW
+curses.A_NORMAL
+curses.A_PROTECT
+curses.A_REVERSE
+curses.A_RIGHT
+curses.A_STANDOUT
+curses.A_TOP
+curses.A_UNDERLINE
+curses.A_VERTICAL
+curses.BUTTON1_CLICKED
+curses.BUTTON1_DOUBLE_CLICKED
+curses.BUTTON1_PRESSED
+curses.BUTTON1_RELEASED
+curses.BUTTON1_TRIPLE_CLICKED
+curses.BUTTON2_CLICKED
+curses.BUTTON2_DOUBLE_CLICKED
+curses.BUTTON2_PRESSED
+curses.BUTTON2_RELEASED
+curses.BUTTON2_TRIPLE_CLICKED
+curses.BUTTON3_CLICKED
+curses.BUTTON3_DOUBLE_CLICKED
+curses.BUTTON3_PRESSED
+curses.BUTTON3_RELEASED
+curses.BUTTON3_TRIPLE_CLICKED
+curses.BUTTON4_CLICKED
+curses.BUTTON4_DOUBLE_CLICKED
+curses.BUTTON4_PRESSED
+curses.BUTTON4_RELEASED
+curses.BUTTON4_TRIPLE_CLICKED
+curses.BUTTON_ALT
+curses.BUTTON_CTRL
+curses.BUTTON_SHIFT
+curses.COLOR_BLACK
+curses.COLOR_BLUE
+curses.COLOR_CYAN
+curses.COLOR_GREEN
+curses.COLOR_MAGENTA
+curses.COLOR_RED
+curses.COLOR_WHITE
+curses.COLOR_YELLOW
+curses.ERR
+curses.KEY_A1
+curses.KEY_A3
+curses.KEY_B2
+curses.KEY_BACKSPACE
+curses.KEY_BEG
+curses.KEY_BREAK
+curses.KEY_BTAB
+curses.KEY_C1
+curses.KEY_C3
+curses.KEY_CANCEL
+curses.KEY_CATAB
+curses.KEY_CLEAR
+curses.KEY_CLOSE
+curses.KEY_COMMAND
+curses.KEY_COPY
+curses.KEY_CREATE
+curses.KEY_CTAB
+curses.KEY_DC
+curses.KEY_DL
+curses.KEY_DOWN
+curses.KEY_EIC
+curses.KEY_END
+curses.KEY_ENTER
+curses.KEY_EOL
+curses.KEY_EOS
+curses.KEY_EXIT
+curses.KEY_F0
+curses.KEY_F1
+curses.KEY_F10
+curses.KEY_F11
+curses.KEY_F12
+curses.KEY_F13
+curses.KEY_F14
+curses.KEY_F15
+curses.KEY_F16
+curses.KEY_F17
+curses.KEY_F18
+curses.KEY_F19
+curses.KEY_F2
+curses.KEY_F20
+curses.KEY_F21
+curses.KEY_F22
+curses.KEY_F23
+curses.KEY_F24
+curses.KEY_F25
+curses.KEY_F26
+curses.KEY_F27
+curses.KEY_F28
+curses.KEY_F29
+curses.KEY_F3
+curses.KEY_F30
+curses.KEY_F31
+curses.KEY_F32
+curses.KEY_F33
+curses.KEY_F34
+curses.KEY_F35
+curses.KEY_F36
+curses.KEY_F37
+curses.KEY_F38
+curses.KEY_F39
+curses.KEY_F4
+curses.KEY_F40
+curses.KEY_F41
+curses.KEY_F42
+curses.KEY_F43
+curses.KEY_F44
+curses.KEY_F45
+curses.KEY_F46
+curses.KEY_F47
+curses.KEY_F48
+curses.KEY_F49
+curses.KEY_F5
+curses.KEY_F50
+curses.KEY_F51
+curses.KEY_F52
+curses.KEY_F53
+curses.KEY_F54
+curses.KEY_F55
+curses.KEY_F56
+curses.KEY_F57
+curses.KEY_F58
+curses.KEY_F59
+curses.KEY_F6
+curses.KEY_F60
+curses.KEY_F61
+curses.KEY_F62
+curses.KEY_F63
+curses.KEY_F7
+curses.KEY_F8
+curses.KEY_F9
+curses.KEY_FIND
+curses.KEY_HELP
+curses.KEY_HOME
+curses.KEY_IC
+curses.KEY_IL
+curses.KEY_LEFT
+curses.KEY_LL
+curses.KEY_MARK
+curses.KEY_MAX
+curses.KEY_MESSAGE
+curses.KEY_MIN
+curses.KEY_MOUSE
+curses.KEY_MOVE
+curses.KEY_NEXT
+curses.KEY_NPAGE
+curses.KEY_OPEN
+curses.KEY_OPTIONS
+curses.KEY_PPAGE
+curses.KEY_PREVIOUS
+curses.KEY_PRINT
+curses.KEY_REDO
+curses.KEY_REFERENCE
+curses.KEY_REFRESH
+curses.KEY_REPLACE
+curses.KEY_RESET
+curses.KEY_RESIZE
+curses.KEY_RESTART
+curses.KEY_RESUME
+curses.KEY_RIGHT
+curses.KEY_SAVE
+curses.KEY_SBEG
+curses.KEY_SCANCEL
+curses.KEY_SCOMMAND
+curses.KEY_SCOPY
+curses.KEY_SCREATE
+curses.KEY_SDC
+curses.KEY_SDL
+curses.KEY_SELECT
+curses.KEY_SEND
+curses.KEY_SEOL
+curses.KEY_SEXIT
+curses.KEY_SF
+curses.KEY_SFIND
+curses.KEY_SHELP
+curses.KEY_SHOME
+curses.KEY_SIC
+curses.KEY_SLEFT
+curses.KEY_SMESSAGE
+curses.KEY_SMOVE
+curses.KEY_SNEXT
+curses.KEY_SOPTIONS
+curses.KEY_SPREVIOUS
+curses.KEY_SPRINT
+curses.KEY_SR
+curses.KEY_SREDO
+curses.KEY_SREPLACE
+curses.KEY_SRESET
+curses.KEY_SRIGHT
+curses.KEY_SRSUME
+curses.KEY_SSAVE
+curses.KEY_SSUSPEND
+curses.KEY_STAB
+curses.KEY_SUNDO
+curses.KEY_SUSPEND
+curses.KEY_UNDO
+curses.KEY_UP
+curses.OK
+curses.REPORT_MOUSE_POSITION
+curses.ascii
+curses.ascii.ACK
+curses.ascii.BEL
+curses.ascii.BS
+curses.ascii.CAN
+curses.ascii.CR
+curses.ascii.DC1
+curses.ascii.DC2
+curses.ascii.DC3
+curses.ascii.DC4
+curses.ascii.DEL
+curses.ascii.DLE
+curses.ascii.EM
+curses.ascii.ENQ
+curses.ascii.EOT
+curses.ascii.ESC
+curses.ascii.ETB
+curses.ascii.ETX
+curses.ascii.FF
+curses.ascii.FS
+curses.ascii.GS
+curses.ascii.HT
+curses.ascii.LF
+curses.ascii.NAK
+curses.ascii.NL
+curses.ascii.NUL
+curses.ascii.RS
+curses.ascii.SI
+curses.ascii.SO
+curses.ascii.SOH
+curses.ascii.SP
+curses.ascii.STX
+curses.ascii.SUB
+curses.ascii.SYN
+curses.ascii.TAB
+curses.ascii.US
+curses.ascii.VT
+curses.ascii.alt(??)
+curses.ascii.ascii(??)
+curses.ascii.controlnames
+curses.ascii.ctrl(??)
+curses.ascii.isalnum(??)
+curses.ascii.isalpha(??)
+curses.ascii.isascii(??)
+curses.ascii.isblank(??)
+curses.ascii.iscntrl(??)
+curses.ascii.isctrl(??)
+curses.ascii.isdigit(??)
+curses.ascii.isgraph(??)
+curses.ascii.islower(??)
+curses.ascii.ismeta(??)
+curses.ascii.isprint(??)
+curses.ascii.ispunct(??)
+curses.ascii.isspace(??)
+curses.ascii.isupper(??)
+curses.ascii.isxdigit(??)
+curses.ascii.unctrl(??)
+curses.baudrate
+curses.beep
+curses.can_change_color
+curses.cbreak
+curses.color_content
+curses.color_pair
+curses.curs_set
+curses.def_prog_mode
+curses.def_shell_mode
+curses.delay_output
+curses.doupdate
+curses.echo
+curses.endwin
+curses.erasechar
+curses.error(??)
+curses.filter
+curses.flash
+curses.flushinp
+curses.getmouse
+curses.getsyx
+curses.getwin
+curses.halfdelay
+curses.has_colors
+curses.has_ic
+curses.has_il
+curses.has_key
+curses.has_key.has_key(??)
+curses.init_color
+curses.init_pair
+curses.initscr(??)
+curses.intrflush
+curses.isendwin
+curses.keyname
+curses.killchar
+curses.longname
+curses.meta
+curses.mouseinterval
+curses.mousemask
+curses.napms
+curses.newpad
+curses.newwin
+curses.nl
+curses.nocbreak
+curses.noecho
+curses.nonl
+curses.noqiflush
+curses.noraw
+curses.pair_content
+curses.pair_number
+curses.panel
+curses.panel.bottom_panel
+curses.panel.error(??)
+curses.panel.new_panel
+curses.panel.top_panel
+curses.panel.update_panels
+curses.panel.version
+curses.putp
+curses.qiflush
+curses.raw
+curses.reset_prog_mode
+curses.reset_shell_mode
+curses.resetty
+curses.savetty
+curses.setsyx
+curses.setupterm
+curses.start_color(??)
+curses.termattrs
+curses.termname
+curses.textpad
+curses.textpad.Textbox(??)
+curses.textpad.ascii
+curses.textpad.curses
+curses.textpad.rectangle(??)
+curses.tigetflag
+curses.tigetnum
+curses.tigetstr
+curses.tparm
+curses.typeahead
+curses.unctrl
+curses.ungetch
+curses.ungetmouse
+curses.use_default_colors
+curses.use_env
+curses.version
+curses.wrapper(??)
+curses.wrapper.func_closure
+curses.wrapper.func_code
+curses.wrapper.func_defaults
+curses.wrapper.func_dict
+curses.wrapper.func_doc
+curses.wrapper.func_globals
+curses.wrapper.func_name
+datetime.MAXYEAR
+datetime.MINYEAR
+datetime.date(year, month, day) --> date object
+datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])
+datetime.datetime_CAPI
+datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object
+datetime.timedelta
+datetime.tzinfo
+dbhash.bsddb
+dbhash.error(??)
+dbhash.open(??)
+dbhash.sys
+decimal.ALWAYS_ROUND
+decimal.BasicContext
+decimal.Clamped(??)
+decimal.Context
+decimal.ConversionSyntax(??)
+decimal.Decimal
+decimal.DecimalException(??)
+decimal.DefaultContext
+decimal.DivisionByZero(??)
+decimal.DivisionImpossible(??)
+decimal.DivisionUndefined(??)
+decimal.ExtendedContext
+decimal.Inexact(??)
+decimal.Inf
+decimal.Infsign
+decimal.InvalidContext(??)
+decimal.InvalidOperation(??)
+decimal.NEVER_ROUND
+decimal.NaN
+decimal.Overflow(??)
+decimal.ROUND_CEILING
+decimal.ROUND_DOWN
+decimal.ROUND_FLOOR
+decimal.ROUND_HALF_DOWN
+decimal.ROUND_HALF_EVEN
+decimal.ROUND_HALF_UP
+decimal.ROUND_UP
+decimal.Rounded(??)
+decimal.Subnormal(??)
+decimal.Underflow(??)
+decimal.getcontext(??)
+decimal.negInf
+decimal.setcontext(??)
+delattr(object, name)
+dict() -> new empty dictionary.
+difflib.Differ(??)
+difflib.HtmlDiff
+difflib.IS_CHARACTER_JUNK(??)
+difflib.IS_LINE_JUNK(??)
+difflib.SequenceMatcher(??)
+difflib.context_diff(??)
+difflib.get_close_matches(??)
+difflib.heapq
+difflib.ndiff(??)
+difflib.restore(??)
+difflib.unified_diff(??)
+dir([object]) -> list of strings
+dircache.annotate(??)
+dircache.cache
+dircache.listdir(??)
+dircache.opendir(??)
+dircache.os
+dircache.reset(??)
+dis.EXTENDED_ARG
+dis.HAVE_ARGUMENT
+dis.cmp_op
+dis.dis(??)
+dis.disassemble(??)
+dis.disassemble_string(??)
+dis.disco(??)
+dis.distb(??)
+dis.findlabels(??)
+dis.findlinestarts(??)
+dis.hascompare
+dis.hasconst
+dis.hasfree
+dis.hasjabs
+dis.hasjrel
+dis.haslocal
+dis.hasname
+dis.opmap
+dis.opname
+dis.sys
+dis.types
+divmod(x, y) -> (div, mod)
+doctest.BLANKLINE_MARKER
+doctest.COMPARISON_FLAGS
+doctest.DONT_ACCEPT_BLANKLINE
+doctest.DONT_ACCEPT_TRUE_FOR_1
+doctest.DebugRunner(??)
+doctest.DocFileCase
+doctest.DocFileSuite(??)
+doctest.DocFileTest(??)
+doctest.DocTest(??)
+doctest.DocTestCase
+doctest.DocTestFailure(??)
+doctest.DocTestFinder(??)
+doctest.DocTestParser(??)
+doctest.DocTestRunner(??)
+doctest.DocTestSuite(??)
+doctest.ELLIPSIS
+doctest.ELLIPSIS_MARKER
+doctest.Example(??)
+doctest.IGNORE_EXCEPTION_DETAIL
+doctest.NORMALIZE_WHITESPACE
+doctest.OPTIONFLAGS_BY_NAME
+doctest.OutputChecker(??)
+doctest.REPORTING_FLAGS
+doctest.REPORT_CDIFF
+doctest.REPORT_NDIFF
+doctest.REPORT_ONLY_FIRST_FAILURE
+doctest.REPORT_UDIFF
+doctest.StringIO(??)
+doctest.Tester(??)
+doctest.UnexpectedException(??)
+doctest.debug(??)
+doctest.debug_script(??)
+doctest.debug_src(??)
+doctest.difflib
+doctest.inspect
+doctest.is_private(??)
+doctest.linecache
+doctest.master
+doctest.os
+doctest.pdb
+doctest.re
+doctest.register_optionflag(??)
+doctest.run_docstring_examples(??)
+doctest.script_from_examples(??)
+doctest.set_unittest_reportflags(??)
+doctest.sys
+doctest.tempfile
+doctest.testfile(??)
+doctest.testmod(??)
+doctest.testsource(??)
+doctest.traceback
+doctest.types
+doctest.unittest
+doctest.warnings
+dumbdbm.UserDict
+dumbdbm.error(??)
+dumbdbm.open(??)
+dummy_thread.LockType
+dummy_thread.allocate_lock(??)
+dummy_thread.error(??)
+dummy_thread.exit(??)
+dummy_thread.get_ident(??)
+dummy_thread.interrupt_main(??)
+dummy_thread.start_new_thread(??)
+dummy_threading.BoundedSemaphore(??)
+dummy_threading.Condition(??)
+dummy_threading.Event(??)
+dummy_threading.Lock(??)
+dummy_threading.RLock(??)
+dummy_threading.Semaphore(??)
+dummy_threading.Thread
+dummy_threading.Timer(??)
+dummy_threading.activeCount(??)
+dummy_threading.currentThread(??)
+dummy_threading.enumerate(??)
+dummy_threading.local
+dummy_threading.setprofile(??)
+dummy_threading.settrace(??)
+dummy_threading.threading
+email.Charset
+email.Charset.ALIASES
+email.Charset.BASE64
+email.Charset.CHARSETS
+email.Charset.CODEC_MAP
+email.Charset.Charset(??)
+email.Charset.DEFAULT_CHARSET
+email.Charset.MISC_LEN
+email.Charset.QP
+email.Charset.SHORTEST
+email.Charset.add_alias(??)
+email.Charset.add_charset(??)
+email.Charset.add_codec(??)
+email.Charset.email
+email.Charset.encode_7or8bit(??)
+email.Encoders
+email.Encoders.base64
+email.Encoders.encode_7or8bit(??)
+email.Encoders.encode_base64(??)
+email.Encoders.encode_noop(??)
+email.Encoders.encode_quopri(??)
+email.Errors
+email.Errors.BoundaryError(??)
+email.Errors.FirstHeaderLineIsContinuationDefect(??)
+email.Errors.HeaderParseError(??)
+email.Errors.MalformedHeaderDefect(??)
+email.Errors.MessageDefect(??)
+email.Errors.MessageError(??)
+email.Errors.MessageParseError(??)
+email.Errors.MisplacedEnvelopeHeaderDefect(??)
+email.Errors.MultipartConversionError(??)
+email.Errors.MultipartInvariantViolationDefect(??)
+email.Errors.NoBoundaryInMultipartDefect(??)
+email.Errors.StartBoundaryNotFoundDefect(??)
+email.FeedParser
+email.FeedParser.BufferedSubFile
+email.FeedParser.EMPTYSTRING
+email.FeedParser.Errors
+email.FeedParser.FeedParser(??)
+email.FeedParser.Message
+email.FeedParser.NL
+email.FeedParser.NLCRE
+email.FeedParser.NLCRE_bol
+email.FeedParser.NLCRE_crack
+email.FeedParser.NLCRE_eol
+email.FeedParser.NeedMoreData
+email.FeedParser.headerRE
+email.FeedParser.re
+email.Generator.DecodedGenerator(??)
+email.Generator.Generator(??)
+email.Generator.Header(??)
+email.Generator.NL
+email.Generator.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+email.Generator.UNDERSCORE
+email.Generator.fcre
+email.Generator.random
+email.Generator.re
+email.Generator.sys
+email.Generator.time
+email.Generator.warnings
+email.Header
+email.Header.Charset(??)
+email.Header.Header(??)
+email.Header.HeaderParseError(??)
+email.Header.MAXLINELEN
+email.Header.NL
+email.Header.SPACE
+email.Header.SPACE8
+email.Header.UEMPTYSTRING
+email.Header.USASCII
+email.Header.USPACE
+email.Header.UTF8
+email.Header.binascii
+email.Header.decode_header(??)
+email.Header.ecre
+email.Header.email
+email.Header.fcre
+email.Header.make_header(??)
+email.Header.re
+email.Iterators
+email.Iterators.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+email.Iterators.body_line_iterator(??)
+email.Iterators.sys
+email.Iterators.typed_subpart_iterator(??)
+email.Iterators.walk(??)
+email.MIMEAudio
+email.MIMEAudio.Encoders
+email.MIMEAudio.Errors
+email.MIMEAudio.MIMEAudio(??)
+email.MIMEAudio.MIMENonMultipart(??)
+email.MIMEAudio.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+email.MIMEAudio.sndhdr
+email.MIMEBase
+email.MIMEBase.MIMEBase(??)
+email.MIMEBase.Message
+email.MIMEImage
+email.MIMEImage.Encoders
+email.MIMEImage.Errors
+email.MIMEImage.MIMEImage(??)
+email.MIMEImage.MIMENonMultipart(??)
+email.MIMEImage.imghdr
+email.MIMEMessage.MIMEMessage(??)
+email.MIMEMessage.MIMENonMultipart(??)
+email.MIMEMessage.Message
+email.MIMEMultipart
+email.MIMEMultipart.MIMEBase
+email.MIMEMultipart.MIMEMultipart(??)
+email.MIMENonMultipart
+email.MIMENonMultipart.Errors
+email.MIMENonMultipart.MIMEBase
+email.MIMENonMultipart.MIMENonMultipart(??)
+email.MIMEText
+email.MIMEText.MIMENonMultipart(??)
+email.MIMEText.MIMEText(??)
+email.MIMEText.encode_7or8bit(??)
+email.Message
+email.Message.Charset
+email.Message.Errors
+email.Message.Message(??)
+email.Message.SEMISPACE
+email.Message.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+email.Message.Utils
+email.Message.binascii
+email.Message.paramre
+email.Message.re
+email.Message.tspecials
+email.Message.uu
+email.Message.warnings
+email.Parser
+email.Parser.FeedParser(??)
+email.Parser.HeaderParser(??)
+email.Parser.Message(??)
+email.Parser.Parser(??)
+email.Parser.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+email.Parser.warnings
+email.Utils
+email.Utils.COMMASPACE
+email.Utils.CRLF
+email.Utils.EMPTYSTRING
+email.Utils.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+email.Utils.UEMPTYSTRING
+email.Utils.base64
+email.Utils.collapse_rfc2231_value(??)
+email.Utils.decode_params(??)
+email.Utils.decode_rfc2231(??)
+email.Utils.ecre
+email.Utils.encode_rfc2231(??)
+email.Utils.escapesre
+email.Utils.fix_eols(??)
+email.Utils.formataddr(??)
+email.Utils.formatdate(??)
+email.Utils.getaddresses(??)
+email.Utils.make_msgid(??)
+email.Utils.mktime_tz(??)
+email.Utils.os
+email.Utils.parseaddr(??)
+email.Utils.parsedate(??)
+email.Utils.parsedate_tz(??)
+email.Utils.quote(??)
+email.Utils.random
+email.Utils.re
+email.Utils.rfc2231_continuation
+email.Utils.socket
+email.Utils.specialsre
+email.Utils.time
+email.Utils.unquote(??)
+email.Utils.warnings
+email.base64MIME
+email.base64MIME.CRLF
+email.base64MIME.EMPTYSTRING
+email.base64MIME.MISC_LEN
+email.base64MIME.NL
+email.base64MIME.a2b_base64
+email.base64MIME.b2a_base64
+email.base64MIME.base64_len(??)
+email.base64MIME.body_decode(??)
+email.base64MIME.body_encode(??)
+email.base64MIME.decode(??)
+email.base64MIME.decodestring(??)
+email.base64MIME.encode(??)
+email.base64MIME.encodestring(??)
+email.base64MIME.fix_eols(??)
+email.base64MIME.header_encode(??)
+email.base64MIME.re
+email.message_from_file(??)
+email.message_from_string(??)
+email.quopriMIME
+email.quopriMIME.CRLF
+email.quopriMIME.MISC_LEN
+email.quopriMIME.NL
+email.quopriMIME.body_decode(??)
+email.quopriMIME.body_encode(??)
+email.quopriMIME.body_quopri_check(??)
+email.quopriMIME.body_quopri_len(??)
+email.quopriMIME.bqre
+email.quopriMIME.decode(??)
+email.quopriMIME.decodestring(??)
+email.quopriMIME.encode(??)
+email.quopriMIME.encodestring(??)
+email.quopriMIME.fix_eols(??)
+email.quopriMIME.header_decode(??)
+email.quopriMIME.header_encode(??)
+email.quopriMIME.header_quopri_check(??)
+email.quopriMIME.header_quopri_len(??)
+email.quopriMIME.hexdigits
+email.quopriMIME.hqre
+email.quopriMIME.quote(??)
+email.quopriMIME.re
+email.quopriMIME.unquote(??)
+enumerate(iterable) -> iterator for index, value of iterable
+errno.E2BIG
+errno.EACCES
+errno.EADDRINUSE
+errno.EADDRNOTAVAIL
+errno.EADV
+errno.EAFNOSUPPORT
+errno.EAGAIN
+errno.EALREADY
+errno.EBADE
+errno.EBADF
+errno.EBADFD
+errno.EBADMSG
+errno.EBADR
+errno.EBADRQC
+errno.EBADSLT
+errno.EBFONT
+errno.EBUSY
+errno.ECHILD
+errno.ECHRNG
+errno.ECOMM
+errno.ECONNABORTED
+errno.ECONNREFUSED
+errno.ECONNRESET
+errno.EDEADLK
+errno.EDEADLOCK
+errno.EDESTADDRREQ
+errno.EDOM
+errno.EDOTDOT
+errno.EDQUOT
+errno.EEXIST
+errno.EFAULT
+errno.EFBIG
+errno.EHOSTDOWN
+errno.EHOSTUNREACH
+errno.EIDRM
+errno.EILSEQ
+errno.EINPROGRESS
+errno.EINTR
+errno.EINVAL
+errno.EIO
+errno.EISCONN
+errno.EISDIR
+errno.EISNAM
+errno.EL2HLT
+errno.EL2NSYNC
+errno.EL3HLT
+errno.EL3RST
+errno.ELIBACC
+errno.ELIBBAD
+errno.ELIBEXEC
+errno.ELIBMAX
+errno.ELIBSCN
+errno.ELNRNG
+errno.ELOOP
+errno.EMFILE
+errno.EMLINK
+errno.EMSGSIZE
+errno.EMULTIHOP
+errno.ENAMETOOLONG
+errno.ENAVAIL
+errno.ENETDOWN
+errno.ENETRESET
+errno.ENETUNREACH
+errno.ENFILE
+errno.ENOANO
+errno.ENOBUFS
+errno.ENOCSI
+errno.ENODATA
+errno.ENODEV
+errno.ENOENT
+errno.ENOEXEC
+errno.ENOLCK
+errno.ENOLINK
+errno.ENOMEM
+errno.ENOMSG
+errno.ENONET
+errno.ENOPKG
+errno.ENOPROTOOPT
+errno.ENOSPC
+errno.ENOSR
+errno.ENOSTR
+errno.ENOSYS
+errno.ENOTBLK
+errno.ENOTCONN
+errno.ENOTDIR
+errno.ENOTEMPTY
+errno.ENOTNAM
+errno.ENOTSOCK
+errno.ENOTTY
+errno.ENOTUNIQ
+errno.ENXIO
+errno.EOPNOTSUPP
+errno.EOVERFLOW
+errno.EPERM
+errno.EPFNOSUPPORT
+errno.EPIPE
+errno.EPROTO
+errno.EPROTONOSUPPORT
+errno.EPROTOTYPE
+errno.ERANGE
+errno.EREMCHG
+errno.EREMOTE
+errno.EREMOTEIO
+errno.ERESTART
+errno.EROFS
+errno.ESHUTDOWN
+errno.ESOCKTNOSUPPORT
+errno.ESPIPE
+errno.ESRCH
+errno.ESRMNT
+errno.ESTALE
+errno.ESTRPIPE
+errno.ETIME
+errno.ETIMEDOUT
+errno.ETOOMANYREFS
+errno.ETXTBSY
+errno.EUCLEAN
+errno.EUNATCH
+errno.EUSERS
+errno.EWOULDBLOCK
+errno.EXDEV
+errno.EXFULL
+errno.errorcode
+eval(source[, globals[, locals]]) -> value
+exceptions.ArithmeticError(??)
+exceptions.AssertionError(??)
+exceptions.AttributeError(??)
+exceptions.DeprecationWarning(??)
+exceptions.EOFError(??)
+exceptions.EnvironmentError(??)
+exceptions.Exception(??)
+exceptions.FloatingPointError(??)
+exceptions.FutureWarning(??)
+exceptions.IOError(??)
+exceptions.ImportError(??)
+exceptions.IndentationError(??)
+exceptions.IndexError(??)
+exceptions.KeyError(??)
+exceptions.KeyboardInterrupt(??)
+exceptions.LookupError(??)
+exceptions.MemoryError(??)
+exceptions.NameError(??)
+exceptions.NotImplementedError(??)
+exceptions.OSError(??)
+exceptions.OverflowError(??)
+exceptions.OverflowWarning(??)
+exceptions.PendingDeprecationWarning(??)
+exceptions.ReferenceError(??)
+exceptions.RuntimeError(??)
+exceptions.RuntimeWarning(??)
+exceptions.StandardError(??)
+exceptions.StopIteration(??)
+exceptions.SyntaxError(??)
+exceptions.SyntaxWarning(??)
+exceptions.SystemError(??)
+exceptions.SystemExit(??)
+exceptions.TabError(??)
+exceptions.TypeError(??)
+exceptions.UnboundLocalError(??)
+exceptions.UnicodeDecodeError(??)
+exceptions.UnicodeEncodeError(??)
+exceptions.UnicodeError(??)
+exceptions.UnicodeTranslateError(??)
+exceptions.UserWarning(??)
+exceptions.ValueError(??)
+exceptions.Warning(??)
+exceptions.ZeroDivisionError(??)
+execfile(filename[, globals[, locals]])
+exit
+fcntl.DN_ACCESS
+fcntl.DN_ATTRIB
+fcntl.DN_CREATE
+fcntl.DN_DELETE
+fcntl.DN_MODIFY
+fcntl.DN_MULTISHOT
+fcntl.DN_RENAME
+fcntl.FD_CLOEXEC
+fcntl.F_DUPFD
+fcntl.F_EXLCK
+fcntl.F_GETFD
+fcntl.F_GETFL
+fcntl.F_GETLEASE
+fcntl.F_GETLK
+fcntl.F_GETLK64
+fcntl.F_GETOWN
+fcntl.F_GETSIG
+fcntl.F_NOTIFY
+fcntl.F_RDLCK
+fcntl.F_SETFD
+fcntl.F_SETFL
+fcntl.F_SETLEASE
+fcntl.F_SETLK
+fcntl.F_SETLK64
+fcntl.F_SETLKW
+fcntl.F_SETLKW64
+fcntl.F_SETOWN
+fcntl.F_SETSIG
+fcntl.F_SHLCK
+fcntl.F_UNLCK
+fcntl.F_WRLCK
+fcntl.I_ATMARK
+fcntl.I_CANPUT
+fcntl.I_CKBAND
+fcntl.I_FDINSERT
+fcntl.I_FIND
+fcntl.I_FLUSH
+fcntl.I_FLUSHBAND
+fcntl.I_GETBAND
+fcntl.I_GETCLTIME
+fcntl.I_GETSIG
+fcntl.I_GRDOPT
+fcntl.I_GWROPT
+fcntl.I_LINK
+fcntl.I_LIST
+fcntl.I_LOOK
+fcntl.I_NREAD
+fcntl.I_PEEK
+fcntl.I_PLINK
+fcntl.I_POP
+fcntl.I_PUNLINK
+fcntl.I_PUSH
+fcntl.I_RECVFD
+fcntl.I_SENDFD
+fcntl.I_SETCLTIME
+fcntl.I_SETSIG
+fcntl.I_SRDOPT
+fcntl.I_STR
+fcntl.I_SWROPT
+fcntl.I_UNLINK
+fcntl.LOCK_EX
+fcntl.LOCK_MAND
+fcntl.LOCK_NB
+fcntl.LOCK_READ
+fcntl.LOCK_RW
+fcntl.LOCK_SH
+fcntl.LOCK_UN
+fcntl.LOCK_WRITE
+fcntl.fcntl(fd, opt, [arg])
+fcntl.flock(fd, operation)
+fcntl.ioctl(fd, opt[, arg[, mutate_flag]])
+fcntl.lockf (fd, operation, length=0, start=0, whence=0)
+file(name[, mode[, buffering]]) -> file object
+filecmp.BUFSIZE
+filecmp.cmp(??)
+filecmp.cmpfiles(??)
+filecmp.demo(??)
+filecmp.dircmp(??)
+filecmp.ifilter(function or None, sequence) --> ifilter object
+filecmp.ifilterfalse(function or None, sequence) --> ifilterfalse object
+filecmp.imap(func, *iterables) --> imap object
+filecmp.izip(iter1 [,iter2 [...]]) --> izip object
+filecmp.os
+filecmp.stat
+filecmp.warnings
+fileinput.DEFAULT_BUFSIZE
+fileinput.FileInput(??)
+fileinput.close(??)
+fileinput.filelineno(??)
+fileinput.filename(??)
+fileinput.input([files[, inplace[, backup]]])
+fileinput.isfirstline(??)
+fileinput.isstdin(??)
+fileinput.lineno(??)
+fileinput.nextfile(??)
+fileinput.os
+fileinput.sys
+filter(function or None, sequence) -> list, tuple, or string
+float(x) -> floating point number
+fnmatch.filter(??)
+fnmatch.fnmatch(??)
+fnmatch.fnmatchcase(??)
+fnmatch.re
+fnmatch.translate(??)
+formatter.AS_IS
+formatter.AbstractFormatter(??)
+formatter.AbstractWriter(??)
+formatter.DumbWriter(??)
+formatter.NullFormatter(??)
+formatter.NullWriter(??)
+formatter.sys
+formatter.test(??)
+fpformat.NotANumber(??)
+fpformat.decoder
+fpformat.extract(??)
+fpformat.fix(??)
+fpformat.re
+fpformat.roundfrac(??)
+fpformat.sci(??)
+fpformat.test(??)
+fpformat.unexpo(??)
+frozenset(iterable) --> frozenset object
+ftplib.CRLF
+ftplib.Error(??)
+ftplib.FTP(??)
+ftplib.FTP_PORT
+ftplib.MSG_OOB
+ftplib.Netrc(??)
+ftplib.all_errors
+ftplib.error_perm(??)
+ftplib.error_proto(??)
+ftplib.error_reply(??)
+ftplib.error_temp(??)
+ftplib.ftpcp(??)
+ftplib.os
+ftplib.parse150(??)
+ftplib.parse227(??)
+ftplib.parse229(??)
+ftplib.parse257(??)
+ftplib.print_line(??)
+ftplib.socket
+ftplib.sys
+ftplib.test(??)
+gc.DEBUG_COLLECTABLE
+gc.DEBUG_INSTANCES
+gc.DEBUG_LEAK
+gc.DEBUG_OBJECTS
+gc.DEBUG_SAVEALL
+gc.DEBUG_STATS
+gc.DEBUG_UNCOLLECTABLE
+gc.collect() -> n
+gc.disable() -> None
+gc.enable() -> None
+gc.garbage
+gc.get_debug() -> flags
+gc.get_objects() -> [...]
+gc.get_referents(*objs) -> list
+gc.get_referrers(*objs) -> list
+gc.get_threshold() -> (threshold0, threshold1, threshold2)
+gc.isenabled() -> status
+gc.set_debug(flags) -> None
+gc.set_threshold(threshold0, [threshold1, threshold2]) -> None
+gdbm.error(??)
+gdbm.open(filename, [flags, [mode]])  -> dbm_object
+gdbm.open_flags
+getattr(object, name[, default]) -> value
+getopt.GetoptError(??)
+getopt.do_longs(??)
+getopt.do_shorts(??)
+getopt.error(??)
+getopt.getopt(args, options[, long_options]) -> opts, args
+getopt.gnu_getopt(??)
+getopt.long_has_args(??)
+getopt.os
+getopt.short_has_arg(??)
+getpass.default_getpass(??)
+getpass.getpass(??)
+getpass.getuser(??)
+getpass.sys
+getpass.termios
+getpass.unix_getpass(??)
+getpass.win_getpass(??)
+gettext.Catalog(??)
+gettext.ENOENT
+gettext.GNUTranslations(??)
+gettext.NullTranslations(??)
+gettext.bind_textdomain_codeset(??)
+gettext.bindtextdomain(??)
+gettext.c2py(??)
+gettext.copy
+gettext.dgettext(??)
+gettext.dngettext(??)
+gettext.find(??)
+gettext.gettext(??)
+gettext.install(??)
+gettext.ldgettext(??)
+gettext.ldngettext(??)
+gettext.lgettext(??)
+gettext.lngettext(??)
+gettext.locale
+gettext.ngettext(??)
+gettext.os
+gettext.re
+gettext.struct
+gettext.sys
+gettext.test(??)
+gettext.textdomain(??)
+gettext.translation(??)
+glob.fnmatch
+glob.glob(??)
+glob.glob1(??)
+glob.has_magic(??)
+glob.magic_check
+glob.os
+glob.re
+globals() -> dictionary
+gopherlib.A_BINARY
+gopherlib.A_CALENDAR
+gopherlib.A_CSO
+gopherlib.A_DUPLICATE
+gopherlib.A_ERROR
+gopherlib.A_EVENT
+gopherlib.A_GIF
+gopherlib.A_HTML
+gopherlib.A_IMAGE
+gopherlib.A_INDEX
+gopherlib.A_MACBINHEX
+gopherlib.A_MENU
+gopherlib.A_MIME
+gopherlib.A_PCBINHEX
+gopherlib.A_PLUS_IMAGE
+gopherlib.A_PLUS_MOVIE
+gopherlib.A_PLUS_SOUND
+gopherlib.A_QUERY
+gopherlib.A_SOUND
+gopherlib.A_TELNET
+gopherlib.A_TEXT
+gopherlib.A_TN3270
+gopherlib.A_UUENCODED
+gopherlib.A_WHOIS
+gopherlib.A_WWW
+gopherlib.CRLF
+gopherlib.DEF_HOST
+gopherlib.DEF_PORT
+gopherlib.DEF_SELECTOR
+gopherlib.TAB
+gopherlib.get_alt_binary(??)
+gopherlib.get_alt_textfile(??)
+gopherlib.get_binary(??)
+gopherlib.get_directory(??)
+gopherlib.get_textfile(??)
+gopherlib.path_to_datatype_name(??)
+gopherlib.path_to_selector(??)
+gopherlib.send_query(??)
+gopherlib.send_selector(??)
+gopherlib.test(??)
+gopherlib.type_to_name(??)
+grp.getgrall() -> list of tuples
+grp.getgrgid(id) -> tuple
+grp.getgrnam(name) -> tuple
+grp.struct_group
+gzip.FCOMMENT
+gzip.FEXTRA
+gzip.FHCRC
+gzip.FNAME
+gzip.FTEXT
+gzip.GzipFile(??)
+gzip.LOWU32(??)
+gzip.READ
+gzip.U32(??)
+gzip.WRITE
+gzip.open(??)
+gzip.read32(??)
+gzip.struct
+gzip.sys
+gzip.time
+gzip.write32(??)
+gzip.write32u(??)
+gzip.zlib
+hasattr(object, name) -> bool
+hash(object) -> integer
+heapq.bisect
+heapq.heapify
+heapq.heappop
+heapq.heappush
+heapq.heapreplace
+heapq.islice(iterable, [start,] stop [, step]) --> islice object
+heapq.nlargest
+heapq.nsmallest
+heapq.repeat(element [,times]) -> create an iterator which returns the element
+help
+hex(number) -> string
+hmac.HMAC(??)
+hmac.digest_size
+hmac.new(??)
+hotshot.Profile(??)
+hotshot.ProfilerError(??)
+hotshot.log
+hotshot.log.ENTER
+hotshot.log.EXIT
+hotshot.log.LINE
+hotshot.log.LogReader(??)
+hotshot.log.WHAT_ADD_INFO
+hotshot.log.WHAT_DEFINE_FILE
+hotshot.log.WHAT_DEFINE_FUNC
+hotshot.log.WHAT_ENTER
+hotshot.log.WHAT_EXIT
+hotshot.log.WHAT_LINENO
+hotshot.log.os
+hotshot.log.parser
+hotshot.log.symbol
+hotshot.log.sys
+hotshot.stats
+hotshot.stats.ENTER
+hotshot.stats.EXIT
+hotshot.stats.FakeCode(??)
+hotshot.stats.FakeFrame(??)
+hotshot.stats.Profile(??)
+hotshot.stats.StatsLoader(??)
+hotshot.stats.hotshot
+hotshot.stats.load(??)
+hotshot.stats.profile
+hotshot.stats.pstats
+hotshot.stones
+hotshot.stones.errno
+hotshot.stones.hotshot
+hotshot.stones.main(??)
+hotshot.stones.os
+hotshot.stones.sys
+hotshot.stones.test
+htmlentitydefs.codepoint2name
+htmlentitydefs.entitydefs
+htmlentitydefs.name2codepoint
+htmllib.AS_IS
+htmllib.HTMLParseError(??)
+htmllib.HTMLParser(??)
+htmllib.sgmllib
+htmllib.test(??)
+httplib.ACCEPTED
+httplib.BAD_GATEWAY
+httplib.BAD_REQUEST
+httplib.BadStatusLine(??)
+httplib.CONFLICT
+httplib.CONTINUE
+httplib.CREATED
+httplib.CannotSendHeader(??)
+httplib.CannotSendRequest(??)
+httplib.EXPECTATION_FAILED
+httplib.FAILED_DEPENDENCY
+httplib.FORBIDDEN
+httplib.FOUND
+httplib.FakeSocket(??)
+httplib.GATEWAY_TIMEOUT
+httplib.GONE
+httplib.HTTP(??)
+httplib.HTTPConnection(??)
+httplib.HTTPException(??)
+httplib.HTTPMessage(??)
+httplib.HTTPResponse(??)
+httplib.HTTPS(??)
+httplib.HTTPSConnection(??)
+httplib.HTTPS_PORT
+httplib.HTTP_PORT
+httplib.HTTP_VERSION_NOT_SUPPORTED
+httplib.IM_USED
+httplib.INSUFFICIENT_STORAGE
+httplib.INTERNAL_SERVER_ERROR
+httplib.ImproperConnectionState(??)
+httplib.IncompleteRead(??)
+httplib.InvalidURL(??)
+httplib.LENGTH_REQUIRED
+httplib.LOCKED
+httplib.LineAndFileWrapper(??)
+httplib.MAXAMOUNT
+httplib.METHOD_NOT_ALLOWED
+httplib.MOVED_PERMANENTLY
+httplib.MULTIPLE_CHOICES
+httplib.MULTI_STATUS
+httplib.NON_AUTHORITATIVE_INFORMATION
+httplib.NOT_ACCEPTABLE
+httplib.NOT_EXTENDED
+httplib.NOT_FOUND
+httplib.NOT_IMPLEMENTED
+httplib.NOT_MODIFIED
+httplib.NO_CONTENT
+httplib.NotConnected(??)
+httplib.OK
+httplib.PARTIAL_CONTENT
+httplib.PAYMENT_REQUIRED
+httplib.PRECONDITION_FAILED
+httplib.PROCESSING
+httplib.PROXY_AUTHENTICATION_REQUIRED
+httplib.REQUESTED_RANGE_NOT_SATISFIABLE
+httplib.REQUEST_ENTITY_TOO_LARGE
+httplib.REQUEST_TIMEOUT
+httplib.REQUEST_URI_TOO_LONG
+httplib.RESET_CONTENT
+httplib.ResponseNotReady(??)
+httplib.SEE_OTHER
+httplib.SERVICE_UNAVAILABLE
+httplib.SSLFile(??)
+httplib.SWITCHING_PROTOCOLS
+httplib.SharedSocket(??)
+httplib.SharedSocketClient(??)
+httplib.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+httplib.TEMPORARY_REDIRECT
+httplib.UNAUTHORIZED
+httplib.UNPROCESSABLE_ENTITY
+httplib.UNSUPPORTED_MEDIA_TYPE
+httplib.UPGRADE_REQUIRED
+httplib.USE_PROXY
+httplib.UnimplementedFileMode(??)
+httplib.UnknownProtocol(??)
+httplib.UnknownTransferEncoding(??)
+httplib.errno
+httplib.error(??)
+httplib.mimetools
+httplib.socket
+httplib.test(??)
+httplib.urlsplit(??)
+id(object) -> integer
+ihooks.BUILTIN_MODULE
+ihooks.BasicModuleImporter(??)
+ihooks.BasicModuleLoader(??)
+ihooks.C_BUILTIN
+ihooks.C_EXTENSION
+ihooks.FROZEN_MODULE
+ihooks.FancyModuleLoader(??)
+ihooks.Hooks(??)
+ihooks.ModuleImporter(??)
+ihooks.ModuleLoader(??)
+ihooks.PKG_DIRECTORY
+ihooks.PY_COMPILED
+ihooks.PY_FROZEN
+ihooks.PY_SOURCE
+ihooks.VERBOSE
+ihooks.current_importer
+ihooks.default_importer
+ihooks.imp
+ihooks.install(??)
+ihooks.os
+ihooks.sys
+ihooks.uninstall(??)
+imaplib.AllowedVersions
+imaplib.CRLF
+imaplib.Commands
+imaplib.Continuation
+imaplib.Debug
+imaplib.Flags
+imaplib.IMAP4(??)
+imaplib.IMAP4_PORT
+imaplib.IMAP4_SSL(??)
+imaplib.IMAP4_SSL_PORT
+imaplib.IMAP4_stream(??)
+imaplib.Int2AP(??)
+imaplib.InternalDate
+imaplib.Internaldate2tuple(??)
+imaplib.Literal
+imaplib.MapCRLF
+imaplib.Mon2num
+imaplib.ParseFlags(??)
+imaplib.Response_code
+imaplib.Time2Internaldate(??)
+imaplib.Untagged_response
+imaplib.Untagged_status
+imaplib.binascii
+imaplib.os
+imaplib.random
+imaplib.re
+imaplib.socket
+imaplib.sys
+imaplib.time
+imghdr.test(??)
+imghdr.test_bmp(??)
+imghdr.test_gif(??)
+imghdr.test_jpeg(??)
+imghdr.test_pbm(??)
+imghdr.test_pgm(??)
+imghdr.test_png(??)
+imghdr.test_ppm(??)
+imghdr.test_rast(??)
+imghdr.test_rgb(??)
+imghdr.test_tiff(??)
+imghdr.test_xbm(??)
+imghdr.testall(??)
+imghdr.tests
+imghdr.what(??)
+imp.C_BUILTIN
+imp.C_EXTENSION
+imp.IMP_HOOK
+imp.PKG_DIRECTORY
+imp.PY_CODERESOURCE
+imp.PY_COMPILED
+imp.PY_FROZEN
+imp.PY_RESOURCE
+imp.PY_SOURCE
+imp.SEARCH_ERROR
+imp.acquire_lock() -> None
+imp.find_module(name, [path]) -> (file, filename, (suffix, mode, type))
+imp.get_frozen_object
+imp.get_magic() -> string
+imp.get_suffixes() -> [(suffix, mode, type), ...]
+imp.init_builtin
+imp.init_frozen
+imp.is_builtin
+imp.is_frozen
+imp.load_compiled
+imp.load_dynamic
+imp.load_module(name, file, filename, (suffix, mode, type)) -> module
+imp.load_package
+imp.load_source
+imp.lock_held() -> boolean
+imp.new_module(name) -> module
+imp.release_lock() -> None
+imputil.BuiltinImporter(??)
+imputil.DynLoadSuffixImporter(??)
+imputil.ImportManager(??)
+imputil.Importer(??)
+imputil.imp
+imputil.marshal
+imputil.py_suffix_importer(??)
+imputil.struct
+imputil.sys
+input([prompt]) -> value
+inspect.BlockFinder(??)
+inspect.CO_NEWLOCALS
+inspect.CO_OPTIMIZED
+inspect.CO_VARARGS
+inspect.CO_VARKEYWORDS
+inspect.EndOfBlock(??)
+inspect.ListReader(??)
+inspect.classify_class_attrs(??)
+inspect.currentframe
+inspect.dis
+inspect.findsource(??)
+inspect.formatargspec(??)
+inspect.formatargvalues(??)
+inspect.getabsfile(??)
+inspect.getargs(??)
+inspect.getargspec(??)
+inspect.getargvalues(??)
+inspect.getblock(??)
+inspect.getclasstree(??)
+inspect.getcomments(??)
+inspect.getdoc(??)
+inspect.getfile(??)
+inspect.getframeinfo(??)
+inspect.getinnerframes(??)
+inspect.getlineno(??)
+inspect.getmembers(??)
+inspect.getmodule(??)
+inspect.getmoduleinfo(??)
+inspect.getmodulename(??)
+inspect.getmro(??)
+inspect.getouterframes(??)
+inspect.getsource(??)
+inspect.getsourcefile(??)
+inspect.getsourcelines(??)
+inspect.imp
+inspect.indentsize(??)
+inspect.isbuiltin(??)
+inspect.isclass(??)
+inspect.iscode(??)
+inspect.isdatadescriptor(??)
+inspect.isframe(??)
+inspect.isfunction(??)
+inspect.ismethod(??)
+inspect.ismethoddescriptor(??)
+inspect.ismodule(??)
+inspect.isroutine(??)
+inspect.istraceback(??)
+inspect.joinseq(??)
+inspect.linecache
+inspect.modulesbyfile
+inspect.os
+inspect.re
+inspect.stack(??)
+inspect.string
+inspect.strseq(??)
+inspect.sys
+inspect.tokenize
+inspect.trace(??)
+inspect.types
+inspect.walktree(??)
+int(x[, base]) -> integer
+intern(string) -> string
+isinstance(object, class-or-type-or-tuple) -> bool
+issubclass(C, B) -> bool
+iter(collection) -> iterator
+itertools.chain(*iterables) --> chain object
+itertools.count([firstval]) --> count object
+itertools.cycle(iterable) --> cycle object
+itertools.dropwhile(predicate, iterable) --> dropwhile object
+itertools.groupby(iterable[, keyfunc]) -> create an iterator which returns
+itertools.ifilter(function or None, sequence) --> ifilter object
+itertools.ifilterfalse(function or None, sequence) --> ifilterfalse object
+itertools.imap(func, *iterables) --> imap object
+itertools.islice(iterable, [start,] stop [, step]) --> islice object
+itertools.izip(iter1 [,iter2 [...]]) --> izip object
+itertools.repeat(element [,times]) -> create an iterator which returns the element
+itertools.starmap(function, sequence) --> starmap object
+itertools.takewhile(predicate, iterable) --> takewhile object
+itertools.tee(iterable, n=2) --> tuple of n independent iterators.
+keyword.iskeyword
+keyword.kwlist
+keyword.main(??)
+len(object) -> integer
+license
+linecache.cache
+linecache.checkcache(??)
+linecache.clearcache(??)
+linecache.getline(??)
+linecache.getlines(??)
+linecache.os
+linecache.sys
+linecache.updatecache(??)
+linuxaudiodev.AFMT_A_LAW
+linuxaudiodev.AFMT_MU_LAW
+linuxaudiodev.AFMT_S16_BE
+linuxaudiodev.AFMT_S16_LE
+linuxaudiodev.AFMT_S16_NE
+linuxaudiodev.AFMT_S8
+linuxaudiodev.AFMT_U16_BE
+linuxaudiodev.AFMT_U16_LE
+linuxaudiodev.AFMT_U8
+linuxaudiodev.error(??)
+linuxaudiodev.open
+list() -> new list
+locale.ABDAY_1
+locale.ABDAY_2
+locale.ABDAY_3
+locale.ABDAY_4
+locale.ABDAY_5
+locale.ABDAY_6
+locale.ABDAY_7
+locale.ABMON_1
+locale.ABMON_10
+locale.ABMON_11
+locale.ABMON_12
+locale.ABMON_2
+locale.ABMON_3
+locale.ABMON_4
+locale.ABMON_5
+locale.ABMON_6
+locale.ABMON_7
+locale.ABMON_8
+locale.ABMON_9
+locale.ALT_DIGITS
+locale.AM_STR
+locale.CHAR_MAX
+locale.CODESET
+locale.CRNCYSTR
+locale.DAY_1
+locale.DAY_2
+locale.DAY_3
+locale.DAY_4
+locale.DAY_5
+locale.DAY_6
+locale.DAY_7
+locale.D_FMT
+locale.D_T_FMT
+locale.ERA
+locale.ERA_D_FMT
+locale.ERA_D_T_FMT
+locale.ERA_T_FMT
+locale.Error(??)
+locale.LC_ALL
+locale.LC_COLLATE
+locale.LC_CTYPE
+locale.LC_MESSAGES
+locale.LC_MONETARY
+locale.LC_NUMERIC
+locale.LC_TIME
+locale.MON_1
+locale.MON_10
+locale.MON_11
+locale.MON_12
+locale.MON_2
+locale.MON_3
+locale.MON_4
+locale.MON_5
+locale.MON_6
+locale.MON_7
+locale.MON_8
+locale.MON_9
+locale.NOEXPR
+locale.PM_STR
+locale.RADIXCHAR
+locale.THOUSEP
+locale.T_FMT
+locale.T_FMT_AMPM
+locale.YESEXPR
+locale.atof(??)
+locale.atoi(??)
+locale.bind_textdomain_codeset(domain, codeset) -> string
+locale.bindtextdomain(domain, dir) -> string
+locale.dcgettext(domain, msg, category) -> string
+locale.dgettext(domain, msg) -> string
+locale.encoding_alias
+locale.format(??)
+locale.getdefaultlocale(??)
+locale.getlocale(??)
+locale.getpreferredencoding(??)
+locale.gettext(msg) -> string
+locale.locale_alias
+locale.localeconv
+locale.nl_langinfo(key) -> string
+locale.normalize(??)
+locale.resetlocale(??)
+locale.setlocale(??)
+locale.str(??)
+locale.strcoll
+locale.strxfrm
+locale.sys
+locale.textdomain(domain) -> string
+locale.windows_locale
+locals() -> dictionary
+logging.BASIC_FORMAT
+logging.BufferingFormatter(??)
+logging.CRITICAL
+logging.DEBUG
+logging.ERROR
+logging.FATAL
+logging.FileHandler(??)
+logging.Filter(??)
+logging.Filterer(??)
+logging.Formatter(??)
+logging.Handler(??)
+logging.INFO
+logging.LogRecord(??)
+logging.Logger(??)
+logging.Manager(??)
+logging.NOTSET
+logging.PlaceHolder(??)
+logging.RootLogger(??)
+logging.StreamHandler(??)
+logging.WARN
+logging.WARNING
+logging.addLevelName(??)
+logging.atexit
+logging.basicConfig(??)
+logging.cStringIO
+logging.codecs
+logging.config
+logging.config.DEFAULT_LOGGING_CONFIG_PORT
+logging.config.RESET_ERROR
+logging.config.StreamRequestHandler(??)
+logging.config.ThreadingTCPServer(??)
+logging.config.fileConfig(??)
+logging.config.listen(??)
+logging.config.logging
+logging.config.os
+logging.config.socket
+logging.config.stopListening(??)
+logging.config.string
+logging.config.struct
+logging.config.sys
+logging.config.thread
+logging.config.threading
+logging.config.traceback
+logging.critical(??)
+logging.currentframe
+logging.debug(??)
+logging.disable(??)
+logging.error(??)
+logging.exception(??)
+logging.fatal(??)
+logging.getLevelName(??)
+logging.getLogger(??)
+logging.getLoggerClass(??)
+logging.handlers
+logging.handlers.BaseRotatingHandler(??)
+logging.handlers.BufferingHandler(??)
+logging.handlers.DEFAULT_HTTP_LOGGING_PORT
+logging.handlers.DEFAULT_SOAP_LOGGING_PORT
+logging.handlers.DEFAULT_TCP_LOGGING_PORT
+logging.handlers.DEFAULT_UDP_LOGGING_PORT
+logging.handlers.DatagramHandler(??)
+logging.handlers.HTTPHandler(??)
+logging.handlers.MemoryHandler(??)
+logging.handlers.NTEventLogHandler(??)
+logging.handlers.RotatingFileHandler(??)
+logging.handlers.SMTPHandler(??)
+logging.handlers.SYSLOG_UDP_PORT
+logging.handlers.SocketHandler(??)
+logging.handlers.SysLogHandler(??)
+logging.handlers.TimedRotatingFileHandler(??)
+logging.handlers.cPickle
+logging.handlers.codecs
+logging.handlers.glob
+logging.handlers.logging
+logging.handlers.os
+logging.handlers.socket
+logging.handlers.string
+logging.handlers.struct
+logging.handlers.sys
+logging.handlers.time
+logging.handlers.types
+logging.info(??)
+logging.log(??)
+logging.makeLogRecord(??)
+logging.os
+logging.raiseExceptions
+logging.root
+logging.setLoggerClass(??)
+logging.shutdown(??)
+logging.string
+logging.sys
+logging.thread
+logging.threading
+logging.time
+logging.traceback
+logging.types
+logging.warn(??)
+logging.warning(??)
+long(x[, base]) -> integer
+macpath.ST_ATIME
+macpath.ST_CTIME
+macpath.ST_DEV
+macpath.ST_GID
+macpath.ST_INO
+macpath.ST_MODE
+macpath.ST_MTIME
+macpath.ST_NLINK
+macpath.ST_SIZE
+macpath.ST_UID
+macpath.S_ENFMT
+macpath.S_IEXEC
+macpath.S_IFBLK
+macpath.S_IFCHR
+macpath.S_IFDIR
+macpath.S_IFIFO
+macpath.S_IFLNK
+macpath.S_IFMT(??)
+macpath.S_IFREG
+macpath.S_IFSOCK
+macpath.S_IMODE(??)
+macpath.S_IREAD
+macpath.S_IRGRP
+macpath.S_IROTH
+macpath.S_IRUSR
+macpath.S_IRWXG
+macpath.S_IRWXO
+macpath.S_IRWXU
+macpath.S_ISBLK(??)
+macpath.S_ISCHR(??)
+macpath.S_ISDIR(??)
+macpath.S_ISFIFO(??)
+macpath.S_ISGID
+macpath.S_ISLNK(??)
+macpath.S_ISREG(??)
+macpath.S_ISSOCK(??)
+macpath.S_ISUID
+macpath.S_ISVTX
+macpath.S_IWGRP
+macpath.S_IWOTH
+macpath.S_IWRITE
+macpath.S_IWUSR
+macpath.S_IXGRP
+macpath.S_IXOTH
+macpath.S_IXUSR
+macpath.abspath(??)
+macpath.altsep
+macpath.basename(??)
+macpath.commonprefix(??)
+macpath.curdir
+macpath.defpath
+macpath.devnull
+macpath.dirname(??)
+macpath.exists(??)
+macpath.expanduser(??)
+macpath.expandvars(??)
+macpath.extsep
+macpath.getatime(??)
+macpath.getctime(??)
+macpath.getmtime(??)
+macpath.getsize(??)
+macpath.isabs(??)
+macpath.isdir(??)
+macpath.isfile(??)
+macpath.islink(??)
+macpath.ismount(??)
+macpath.join(??)
+macpath.lexists(??)
+macpath.norm_error(??)
+macpath.normcase(??)
+macpath.normpath(??)
+macpath.os
+macpath.pardir
+macpath.pathsep
+macpath.realpath(??)
+macpath.sep
+macpath.split(??)
+macpath.splitdrive(??)
+macpath.splitext(??)
+macpath.supports_unicode_filenames
+macpath.walk(??)
+macurl2path.os
+macurl2path.pathname2url(??)
+macurl2path.test(??)
+macurl2path.url2pathname(??)
+macurl2path.urllib
+mailbox.BabylMailbox(??)
+mailbox.MHMailbox(??)
+mailbox.Maildir(??)
+mailbox.MmdfMailbox(??)
+mailbox.PortableUnixMailbox(??)
+mailbox.UnixMailbox(??)
+mailbox.os
+mailbox.rfc822
+mailcap.findmatch(??)
+mailcap.findparam(??)
+mailcap.getcaps(??)
+mailcap.listmailcapfiles(??)
+mailcap.lookup(??)
+mailcap.os
+mailcap.parsefield(??)
+mailcap.parseline(??)
+mailcap.readmailcapfile(??)
+mailcap.show(??)
+mailcap.subst(??)
+mailcap.test(??)
+map(function, sequence[, sequence, ...]) -> list
+markupbase.ParserBase(??)
+marshal.dump
+marshal.dumps
+marshal.load
+marshal.loads
+marshal.version
+math.acos(x)
+math.asin(x)
+math.atan(x)
+math.atan2(y, x)
+math.ceil(x)
+math.cos(x)
+math.cosh(x)
+math.degrees(x) -> converts angle x from radians to degrees
+math.e
+math.exp(x)
+math.fabs(x)
+math.floor(x)
+math.fmod(x,y)
+math.frexp(x)
+math.hypot(x,y)
+math.ldexp(x, i) -> x * (2**i)
+math.log(x[, base]) -> the logarithm of x to the given base.
+math.log10(x) -> the base 10 logarithm of x.
+math.modf(x)
+math.pi
+math.pow(x,y)
+math.radians(x) -> converts angle x from degrees to radians
+math.sin(x)
+math.sinh(x)
+math.sqrt(x)
+math.tan(x)
+math.tanh(x)
+max(sequence) -> value
+md5.MD5Type
+md5.digest_size
+md5.md5
+md5.new([arg]) -> md5 object
+mhlib.Error(??)
+mhlib.FOLDER_PROTECT
+mhlib.Folder(??)
+mhlib.IntSet(??)
+mhlib.MH(??)
+mhlib.MH_PROFILE
+mhlib.MH_SEQUENCES
+mhlib.Message(??)
+mhlib.PATH
+mhlib.SubMessage(??)
+mhlib.bisect
+mhlib.isnumeric(??)
+mhlib.mimetools
+mhlib.multifile
+mhlib.numericprog
+mhlib.os
+mhlib.pickline(??)
+mhlib.re
+mhlib.shutil
+mhlib.sys
+mhlib.test(??)
+mhlib.updateline(??)
+mimetools.Message(??)
+mimetools.choose_boundary(??)
+mimetools.copybinary(??)
+mimetools.copyliteral(??)
+mimetools.decode(??)
+mimetools.decodetab
+mimetools.encode(??)
+mimetools.encodetab
+mimetools.os
+mimetools.pipethrough(??)
+mimetools.pipeto(??)
+mimetools.rfc822
+mimetools.tempfile
+mimetools.uudecode_pipe
+mimetypes.MimeTypes(??)
+mimetypes.add_type(??)
+mimetypes.common_types
+mimetypes.encodings_map
+mimetypes.guess_all_extensions(??)
+mimetypes.guess_extension(??)
+mimetypes.guess_type(??)
+mimetypes.init(??)
+mimetypes.inited
+mimetypes.knownfiles
+mimetypes.os
+mimetypes.posixpath
+mimetypes.read_mime_types(??)
+mimetypes.suffix_map
+mimetypes.types_map
+mimetypes.urllib
+mimify.CHARSET
+mimify.File(??)
+mimify.HeaderFile(??)
+mimify.MAXLEN
+mimify.QUOTE
+mimify.base64_re
+mimify.chrset
+mimify.cte
+mimify.he
+mimify.iso_char
+mimify.mime_char
+mimify.mime_code
+mimify.mime_decode(??)
+mimify.mime_decode_header(??)
+mimify.mime_encode(??)
+mimify.mime_encode_header(??)
+mimify.mime_head
+mimify.mime_header
+mimify.mime_header_char
+mimify.mimify(??)
+mimify.mimify_part(??)
+mimify.mp
+mimify.mv
+mimify.qp
+mimify.re
+mimify.repl
+mimify.sys
+mimify.unmimify(??)
+mimify.unmimify_part(??)
+min(sequence) -> value
+mmap.ACCESS_COPY
+mmap.ACCESS_READ
+mmap.ACCESS_WRITE
+mmap.MAP_ANON
+mmap.MAP_ANONYMOUS
+mmap.MAP_DENYWRITE
+mmap.MAP_EXECUTABLE
+mmap.MAP_PRIVATE
+mmap.MAP_SHARED
+mmap.PAGESIZE
+mmap.PROT_EXEC
+mmap.PROT_READ
+mmap.PROT_WRITE
+mmap.error(??)
+mmap.mmap
+modulefinder.AddPackagePath(??)
+modulefinder.IMPORT_NAME
+modulefinder.LOAD_CONST
+modulefinder.Module(??)
+modulefinder.ModuleFinder(??)
+modulefinder.READ_MODE
+modulefinder.ReplacePackage(??)
+modulefinder.STORE_GLOBAL
+modulefinder.STORE_NAME
+modulefinder.STORE_OPS
+modulefinder.dis
+modulefinder.imp
+modulefinder.marshal
+modulefinder.new
+modulefinder.os
+modulefinder.packagePathMap
+modulefinder.replacePackageMap
+modulefinder.sys
+modulefinder.test(??)
+multifile.Error(??)
+multifile.MultiFile(??)
+mutex.deque(iterable) --> deque object
+mutex.mutex(??)
+netrc.NetrcParseError(??)
+netrc.netrc(??)
+netrc.os
+netrc.shlex
+new.classobj(name, bases, dict)
+new.code
+new.function(code, globals[, name[, argdefs[, closure]]])
+new.instance(class[, dict])
+new.instancemethod(function, instance, class)
+new.module(name[, doc])
+nis.cat
+nis.error(??)
+nis.maps
+nis.match
+nntplib.CRLF
+nntplib.LONGRESP
+nntplib.NNTP(??)
+nntplib.NNTPDataError(??)
+nntplib.NNTPError(??)
+nntplib.NNTPPermanentError(??)
+nntplib.NNTPProtocolError(??)
+nntplib.NNTPReplyError(??)
+nntplib.NNTPTemporaryError(??)
+nntplib.NNTP_PORT
+nntplib.error_data(??)
+nntplib.error_perm(??)
+nntplib.error_proto(??)
+nntplib.error_reply(??)
+nntplib.error_temp(??)
+nntplib.re
+nntplib.socket
+ntpath.abspath(??)
+ntpath.altsep
+ntpath.basename(??)
+ntpath.commonprefix(??)
+ntpath.curdir
+ntpath.defpath
+ntpath.devnull
+ntpath.dirname(??)
+ntpath.exists(??)
+ntpath.expanduser(??)
+ntpath.expandvars(??)
+ntpath.extsep
+ntpath.getatime(??)
+ntpath.getctime(??)
+ntpath.getmtime(??)
+ntpath.getsize(??)
+ntpath.isabs(??)
+ntpath.isdir(??)
+ntpath.isfile(??)
+ntpath.islink(??)
+ntpath.ismount(??)
+ntpath.join(??)
+ntpath.lexists(??)
+ntpath.normcase(??)
+ntpath.normpath(??)
+ntpath.os
+ntpath.pardir
+ntpath.pathsep
+ntpath.realpath(??)
+ntpath.sep
+ntpath.split(??)
+ntpath.splitdrive(??)
+ntpath.splitext(??)
+ntpath.splitunc(??)
+ntpath.stat
+ntpath.supports_unicode_filenames
+ntpath.sys
+ntpath.walk(??)
+nturl2path.pathname2url(??)
+nturl2path.url2pathname(??)
+object
+oct(number) -> string
+opcode.EXTENDED_ARG
+opcode.HAVE_ARGUMENT
+opcode.cmp_op
+opcode.hascompare
+opcode.hasconst
+opcode.hasfree
+opcode.hasjabs
+opcode.hasjrel
+opcode.haslocal
+opcode.hasname
+opcode.opmap
+opcode.opname
+open
+operator.abs(a) -- Same as abs(a).
+operator.add(a, b) -- Same as a + b.
+operator.and_(a, b) -- Same as a & b.
+operator.attrgetter(attr) --> attrgetter object
+operator.concat(a, b) -- Same as a + b, for a and b sequences.
+operator.contains(a, b) -- Same as b in a (note reversed operands).
+operator.countOf(a, b) -- Return the number of times b occurs in a.
+operator.delitem(a, b) -- Same as del a[b].
+operator.delslice(a, b, c) -- Same as del a[b:c].
+operator.div(a, b) -- Same as a / b when __future__.division is not in effect.
+operator.eq(a, b) -- Same as a==b.
+operator.floordiv(a, b) -- Same as a // b.
+operator.ge(a, b) -- Same as a>=b.
+operator.getitem(a, b) -- Same as a[b].
+operator.getslice(a, b, c) -- Same as a[b:c].
+operator.gt(a, b) -- Same as a>b.
+operator.indexOf(a, b) -- Return the first index of b in a.
+operator.inv(a) -- Same as ~a.
+operator.invert(a) -- Same as ~a.
+operator.isCallable(a) -- Same as callable(a).
+operator.isMappingType(a) -- Return True if a has a mapping type, False otherwise.
+operator.isNumberType(a) -- Return True if a has a numeric type, False otherwise.
+operator.isSequenceType(a) -- Return True if a has a sequence type, False otherwise.
+operator.is_(a, b) -- Same as a is b.
+operator.is_not(a, b) -- Same as a is not b.
+operator.itemgetter(item) --> itemgetter object
+operator.le(a, b) -- Same as a<=b.
+operator.lshift(a, b) -- Same as a << b.
+operator.lt(a, b) -- Same as a<b.
+operator.mod(a, b) -- Same as a % b.
+operator.mul(a, b) -- Same as a * b.
+operator.ne(a, b) -- Same as a!=b.
+operator.neg(a) -- Same as -a.
+operator.not_(a) -- Same as not a.
+operator.or_(a, b) -- Same as a | b.
+operator.pos(a) -- Same as +a.
+operator.pow(a, b) -- Same as a**b.
+operator.repeat(a, b) -- Return a * b, where a is a sequence, and b is an integer.
+operator.rshift(a, b) -- Same as a >> b.
+operator.sequenceIncludes(a, b) -- Same as b in a (note reversed operands; deprecated).
+operator.setitem(a, b, c) -- Same as a[b] = c.
+operator.setslice(a, b, c, d) -- Same as a[b:c] = d.
+operator.sub(a, b) -- Same as a - b.
+operator.truediv(a, b) -- Same as a / b when __future__.division is in effect.
+operator.truth(a) -- Return True if a is true, False otherwise.
+operator.xor(a, b) -- Same as a ^ b.
+optparse.BadOptionError(??)
+optparse.HelpFormatter(??)
+optparse.IndentedHelpFormatter(??)
+optparse.NO_DEFAULT
+optparse.OptParseError(??)
+optparse.Option(??)
+optparse.OptionConflictError(??)
+optparse.OptionContainer(??)
+optparse.OptionError(??)
+optparse.OptionGroup(??)
+optparse.OptionParser(??)
+optparse.OptionValueError(??)
+optparse.SUPPRESS_HELP
+optparse.SUPPRESS_USAGE
+optparse.TitledHelpFormatter(??)
+optparse.Values(??)
+optparse.check_builtin(??)
+optparse.check_choice(??)
+optparse.make_option(??)
+optparse.os
+optparse.sys
+optparse.textwrap
+optparse.types
+ord(c) -> integer
+os.EX_CANTCREAT
+os.EX_CONFIG
+os.EX_DATAERR
+os.EX_IOERR
+os.EX_NOHOST
+os.EX_NOINPUT
+os.EX_NOPERM
+os.EX_NOUSER
+os.EX_OK
+os.EX_OSERR
+os.EX_OSFILE
+os.EX_PROTOCOL
+os.EX_SOFTWARE
+os.EX_TEMPFAIL
+os.EX_UNAVAILABLE
+os.EX_USAGE
+os.F_OK
+os.NGROUPS_MAX
+os.O_APPEND
+os.O_CREAT
+os.O_DIRECT
+os.O_DIRECTORY
+os.O_DSYNC
+os.O_EXCL
+os.O_LARGEFILE
+os.O_NDELAY
+os.O_NOCTTY
+os.O_NOFOLLOW
+os.O_NONBLOCK
+os.O_RDONLY
+os.O_RDWR
+os.O_RSYNC
+os.O_SYNC
+os.O_TRUNC
+os.O_WRONLY
+os.P_NOWAIT
+os.P_NOWAITO
+os.P_WAIT
+os.R_OK
+os.TMP_MAX
+os.UserDict
+os.WCONTINUED
+os.WCOREDUMP(status) -> bool
+os.WEXITSTATUS(status) -> integer
+os.WIFCONTINUED(status) -> bool
+os.WIFEXITED(status) -> bool
+os.WIFSIGNALED(status) -> bool
+os.WIFSTOPPED(status) -> bool
+os.WNOHANG
+os.WSTOPSIG(status) -> integer
+os.WTERMSIG(status) -> integer
+os.WUNTRACED
+os.W_OK
+os.X_OK
+os.abort() -> does not return!
+os.access(path, mode) -> 1 if granted, 0 otherwise
+os.altsep
+os.chdir(path)
+os.chmod(path, mode)
+os.chown(path, uid, gid)
+os.chroot(path)
+os.close(fd)
+os.confstr(name) -> string
+os.confstr_names
+os.ctermid() -> string
+os.curdir
+os.defpath
+os.devnull
+os.dup(fd) -> fd2
+os.dup2(old_fd, new_fd)
+os.environ
+os.error(??)
+os.execl(file, *args)
+os.execle(file, *args, env)
+os.execlp(file, *args)
+os.execlpe(file, *args, env)
+os.execv(path, args)
+os.execve(path, args, env)
+os.execvp(??)
+os.execvpe(file, args, env)
+os.extsep
+os.fchdir(fildes)
+os.fdatasync(fildes)
+os.fdopen(fd [, mode='r' [, bufsize]]) -> file_object
+os.fork() -> pid
+os.forkpty() -> (pid, master_fd)
+os.fpathconf(fd, name) -> integer
+os.fstat(fd) -> stat result
+os.fstatvfs(fd) -> statvfs result
+os.fsync(fildes)
+os.ftruncate(fd, length)
+os.getcwd() -> path
+os.getcwdu() -> path
+os.getegid() -> egid
+os.getenv(??)
+os.geteuid() -> euid
+os.getgid() -> gid
+os.getgroups() -> list of group IDs
+os.getloadavg() -> (float, float, float)
+os.getlogin() -> string
+os.getpgid(pid) -> pgid
+os.getpgrp() -> pgrp
+os.getpid() -> pid
+os.getppid() -> ppid
+os.getsid(pid) -> sid
+os.getuid() -> uid
+os.isatty(fd) -> bool
+os.kill(pid, sig)
+os.killpg(pgid, sig)
+os.lchown(path, uid, gid)
+os.linesep
+os.link(src, dst)
+os.listdir(path) -> list_of_strings
+os.lseek(fd, pos, how) -> newpos
+os.lstat(path) -> stat result
+os.major(device) -> major number
+os.makedev(major, minor) -> device number
+os.makedirs(path [, mode=0777])
+os.minor(device) -> minor number
+os.mkdir(path [, mode=0777])
+os.mkfifo(filename [, mode=0666])
+os.mknod(filename [, mode=0600, device])
+os.name
+os.nice(inc) -> new_priority
+os.open(filename, flag [, mode=0777]) -> fd
+os.openpty() -> (master_fd, slave_fd)
+os.pardir
+os.path
+os.pathconf(path, name) -> integer
+os.pathconf_names
+os.pathsep
+os.pipe() -> (read_end, write_end)
+os.popen(command [, mode='r' [, bufsize]]) -> pipe
+os.popen2(??)
+os.popen3(??)
+os.popen4(??)
+os.putenv(key, value)
+os.read(fd, buffersize) -> string
+os.readlink(path) -> path
+os.remove(path)
+os.removedirs(path)
+os.rename(old, new)
+os.renames(old, new)
+os.rmdir(path)
+os.sep
+os.setegid(gid)
+os.seteuid(uid)
+os.setgid(gid)
+os.setgroups(list)
+os.setpgid(pid, pgrp)
+os.setpgrp()
+os.setregid(rgid, egid)
+os.setreuid(ruid, euid)
+os.setsid()
+os.setuid(uid)
+os.spawnl(mode, file, *args) -> integer
+os.spawnle(mode, file, *args, env) -> integer
+os.spawnlp(mode, file, *args) -> integer
+os.spawnlpe(mode, file, *args, env) -> integer
+os.spawnv(mode, file, args) -> integer
+os.spawnve(mode, file, args, env) -> integer
+os.spawnvp(mode, file, args) -> integer
+os.spawnvpe(mode, file, args, env) -> integer
+os.stat(path) -> stat result
+os.stat_float_times([newval]) -> oldval
+os.stat_result
+os.statvfs(path) -> statvfs result
+os.statvfs_result
+os.strerror(code) -> string
+os.symlink(src, dst)
+os.sys
+os.sysconf(name) -> integer
+os.sysconf_names
+os.system(command) -> exit_status
+os.tcgetpgrp(fd) -> pgid
+os.tcsetpgrp(fd, pgid)
+os.tempnam([dir[, prefix]]) -> string
+os.times() -> (utime, stime, cutime, cstime, elapsed_time)
+os.tmpfile() -> file object
+os.tmpnam() -> string
+os.ttyname(fd) -> string
+os.umask(new_mask) -> old_mask
+os.uname() -> (sysname, nodename, release, version, machine)
+os.unlink(path)
+os.unsetenv(key)
+os.urandom(n) -> str
+os.utime(path, (atime, utime))
+os.wait() -> (pid, status)
+os.waitpid(pid, options) -> (pid, status)
+os.walk(??)
+os.write(fd, string) -> byteswritten
+os2emxpath.abspath(??)
+os2emxpath.altsep
+os2emxpath.basename(??)
+os2emxpath.commonprefix(??)
+os2emxpath.curdir
+os2emxpath.defpath
+os2emxpath.devnull
+os2emxpath.dirname(??)
+os2emxpath.exists(??)
+os2emxpath.expanduser(??)
+os2emxpath.expandvars(??)
+os2emxpath.extsep
+os2emxpath.getatime(??)
+os2emxpath.getctime(??)
+os2emxpath.getmtime(??)
+os2emxpath.getsize(??)
+os2emxpath.isabs(??)
+os2emxpath.isdir(??)
+os2emxpath.isfile(??)
+os2emxpath.islink(??)
+os2emxpath.ismount(??)
+os2emxpath.join(??)
+os2emxpath.lexists(??)
+os2emxpath.normcase(??)
+os2emxpath.normpath(??)
+os2emxpath.os
+os2emxpath.pardir
+os2emxpath.pathsep
+os2emxpath.realpath(??)
+os2emxpath.sep
+os2emxpath.split(??)
+os2emxpath.splitdrive(??)
+os2emxpath.splitext(??)
+os2emxpath.splitunc(??)
+os2emxpath.stat
+os2emxpath.supports_unicode_filenames
+os2emxpath.walk(??)
+ossaudiodev.AFMT_AC3
+ossaudiodev.AFMT_A_LAW
+ossaudiodev.AFMT_IMA_ADPCM
+ossaudiodev.AFMT_MPEG
+ossaudiodev.AFMT_MU_LAW
+ossaudiodev.AFMT_QUERY
+ossaudiodev.AFMT_S16_BE
+ossaudiodev.AFMT_S16_LE
+ossaudiodev.AFMT_S16_NE
+ossaudiodev.AFMT_S8
+ossaudiodev.AFMT_U16_BE
+ossaudiodev.AFMT_U16_LE
+ossaudiodev.AFMT_U8
+ossaudiodev.OSSAudioError(??)
+ossaudiodev.SNDCTL_COPR_HALT
+ossaudiodev.SNDCTL_COPR_LOAD
+ossaudiodev.SNDCTL_COPR_RCODE
+ossaudiodev.SNDCTL_COPR_RCVMSG
+ossaudiodev.SNDCTL_COPR_RDATA
+ossaudiodev.SNDCTL_COPR_RESET
+ossaudiodev.SNDCTL_COPR_RUN
+ossaudiodev.SNDCTL_COPR_SENDMSG
+ossaudiodev.SNDCTL_COPR_WCODE
+ossaudiodev.SNDCTL_COPR_WDATA
+ossaudiodev.SNDCTL_DSP_BIND_CHANNEL
+ossaudiodev.SNDCTL_DSP_CHANNELS
+ossaudiodev.SNDCTL_DSP_GETBLKSIZE
+ossaudiodev.SNDCTL_DSP_GETCAPS
+ossaudiodev.SNDCTL_DSP_GETCHANNELMASK
+ossaudiodev.SNDCTL_DSP_GETFMTS
+ossaudiodev.SNDCTL_DSP_GETIPTR
+ossaudiodev.SNDCTL_DSP_GETISPACE
+ossaudiodev.SNDCTL_DSP_GETODELAY
+ossaudiodev.SNDCTL_DSP_GETOPTR
+ossaudiodev.SNDCTL_DSP_GETOSPACE
+ossaudiodev.SNDCTL_DSP_GETSPDIF
+ossaudiodev.SNDCTL_DSP_GETTRIGGER
+ossaudiodev.SNDCTL_DSP_MAPINBUF
+ossaudiodev.SNDCTL_DSP_MAPOUTBUF
+ossaudiodev.SNDCTL_DSP_NONBLOCK
+ossaudiodev.SNDCTL_DSP_POST
+ossaudiodev.SNDCTL_DSP_PROFILE
+ossaudiodev.SNDCTL_DSP_RESET
+ossaudiodev.SNDCTL_DSP_SAMPLESIZE
+ossaudiodev.SNDCTL_DSP_SETDUPLEX
+ossaudiodev.SNDCTL_DSP_SETFMT
+ossaudiodev.SNDCTL_DSP_SETFRAGMENT
+ossaudiodev.SNDCTL_DSP_SETSPDIF
+ossaudiodev.SNDCTL_DSP_SETSYNCRO
+ossaudiodev.SNDCTL_DSP_SETTRIGGER
+ossaudiodev.SNDCTL_DSP_SPEED
+ossaudiodev.SNDCTL_DSP_STEREO
+ossaudiodev.SNDCTL_DSP_SUBDIVIDE
+ossaudiodev.SNDCTL_DSP_SYNC
+ossaudiodev.SNDCTL_FM_4OP_ENABLE
+ossaudiodev.SNDCTL_FM_LOAD_INSTR
+ossaudiodev.SNDCTL_MIDI_INFO
+ossaudiodev.SNDCTL_MIDI_MPUCMD
+ossaudiodev.SNDCTL_MIDI_MPUMODE
+ossaudiodev.SNDCTL_MIDI_PRETIME
+ossaudiodev.SNDCTL_SEQ_CTRLRATE
+ossaudiodev.SNDCTL_SEQ_GETINCOUNT
+ossaudiodev.SNDCTL_SEQ_GETOUTCOUNT
+ossaudiodev.SNDCTL_SEQ_GETTIME
+ossaudiodev.SNDCTL_SEQ_NRMIDIS
+ossaudiodev.SNDCTL_SEQ_NRSYNTHS
+ossaudiodev.SNDCTL_SEQ_OUTOFBAND
+ossaudiodev.SNDCTL_SEQ_PANIC
+ossaudiodev.SNDCTL_SEQ_PERCMODE
+ossaudiodev.SNDCTL_SEQ_RESET
+ossaudiodev.SNDCTL_SEQ_RESETSAMPLES
+ossaudiodev.SNDCTL_SEQ_SYNC
+ossaudiodev.SNDCTL_SEQ_TESTMIDI
+ossaudiodev.SNDCTL_SEQ_THRESHOLD
+ossaudiodev.SNDCTL_SYNTH_CONTROL
+ossaudiodev.SNDCTL_SYNTH_ID
+ossaudiodev.SNDCTL_SYNTH_INFO
+ossaudiodev.SNDCTL_SYNTH_MEMAVL
+ossaudiodev.SNDCTL_SYNTH_REMOVESAMPLE
+ossaudiodev.SNDCTL_TMR_CONTINUE
+ossaudiodev.SNDCTL_TMR_METRONOME
+ossaudiodev.SNDCTL_TMR_SELECT
+ossaudiodev.SNDCTL_TMR_SOURCE
+ossaudiodev.SNDCTL_TMR_START
+ossaudiodev.SNDCTL_TMR_STOP
+ossaudiodev.SNDCTL_TMR_TEMPO
+ossaudiodev.SNDCTL_TMR_TIMEBASE
+ossaudiodev.SOUND_MIXER_ALTPCM
+ossaudiodev.SOUND_MIXER_BASS
+ossaudiodev.SOUND_MIXER_CD
+ossaudiodev.SOUND_MIXER_DIGITAL1
+ossaudiodev.SOUND_MIXER_DIGITAL2
+ossaudiodev.SOUND_MIXER_DIGITAL3
+ossaudiodev.SOUND_MIXER_IGAIN
+ossaudiodev.SOUND_MIXER_IMIX
+ossaudiodev.SOUND_MIXER_LINE
+ossaudiodev.SOUND_MIXER_LINE1
+ossaudiodev.SOUND_MIXER_LINE2
+ossaudiodev.SOUND_MIXER_LINE3
+ossaudiodev.SOUND_MIXER_MIC
+ossaudiodev.SOUND_MIXER_MONITOR
+ossaudiodev.SOUND_MIXER_NRDEVICES
+ossaudiodev.SOUND_MIXER_OGAIN
+ossaudiodev.SOUND_MIXER_PCM
+ossaudiodev.SOUND_MIXER_PHONEIN
+ossaudiodev.SOUND_MIXER_PHONEOUT
+ossaudiodev.SOUND_MIXER_RADIO
+ossaudiodev.SOUND_MIXER_RECLEV
+ossaudiodev.SOUND_MIXER_SPEAKER
+ossaudiodev.SOUND_MIXER_SYNTH
+ossaudiodev.SOUND_MIXER_TREBLE
+ossaudiodev.SOUND_MIXER_VIDEO
+ossaudiodev.SOUND_MIXER_VOLUME
+ossaudiodev.control_labels
+ossaudiodev.control_names
+ossaudiodev.error(??)
+ossaudiodev.open
+ossaudiodev.openmixer
+parser.ASTType
+parser.ParserError(??)
+parser.STType
+parser.ast2list
+parser.ast2tuple
+parser.compileast
+parser.compilest
+parser.expr
+parser.isexpr
+parser.issuite
+parser.sequence2ast
+parser.sequence2st
+parser.st2list
+parser.st2tuple
+parser.suite
+parser.tuple2ast
+parser.tuple2st
+pdb.Pdb(??)
+pdb.Repr(??)
+pdb.TESTCMD
+pdb.bdb
+pdb.cmd
+pdb.find_function(??)
+pdb.help(??)
+pdb.line_prefix
+pdb.linecache
+pdb.main(??)
+pdb.os
+pdb.pm(??)
+pdb.post_mortem(??)
+pdb.pprint
+pdb.re
+pdb.run(??)
+pdb.runcall(??)
+pdb.runctx(??)
+pdb.runeval(??)
+pdb.set_trace(??)
+pdb.sys
+pdb.test(??)
+pdb.traceback
+pickle.APPEND
+pickle.APPENDS
+pickle.BINFLOAT
+pickle.BINGET
+pickle.BININT
+pickle.BININT1
+pickle.BININT2
+pickle.BINPERSID
+pickle.BINPUT
+pickle.BINSTRING
+pickle.BINUNICODE
+pickle.BUILD
+pickle.BooleanType
+pickle.BufferType
+pickle.BuiltinFunctionType
+pickle.BuiltinMethodType
+pickle.ClassType
+pickle.CodeType
+pickle.ComplexType
+pickle.DICT
+pickle.DUP
+pickle.DictProxyType
+pickle.DictType
+pickle.DictionaryType
+pickle.EMPTY_DICT
+pickle.EMPTY_LIST
+pickle.EMPTY_TUPLE
+pickle.EXT1
+pickle.EXT2
+pickle.EXT4
+pickle.EllipsisType
+pickle.FALSE
+pickle.FLOAT
+pickle.FileType
+pickle.FloatType
+pickle.FrameType
+pickle.FunctionType
+pickle.GET
+pickle.GLOBAL
+pickle.GeneratorType
+pickle.HIGHEST_PROTOCOL
+pickle.INST
+pickle.INT
+pickle.InstanceType
+pickle.IntType
+pickle.LIST
+pickle.LONG
+pickle.LONG1
+pickle.LONG4
+pickle.LONG_BINGET
+pickle.LONG_BINPUT
+pickle.LambdaType
+pickle.ListType
+pickle.LongType
+pickle.MARK
+pickle.MethodType
+pickle.ModuleType
+pickle.NEWFALSE
+pickle.NEWOBJ
+pickle.NEWTRUE
+pickle.NONE
+pickle.NoneType
+pickle.NotImplementedType
+pickle.OBJ
+pickle.ObjectType
+pickle.PERSID
+pickle.POP
+pickle.POP_MARK
+pickle.PROTO
+pickle.PUT
+pickle.PickleError(??)
+pickle.Pickler(??)
+pickle.PicklingError(??)
+pickle.PyStringMap
+pickle.REDUCE
+pickle.SETITEM
+pickle.SETITEMS
+pickle.SHORT_BINSTRING
+pickle.STOP
+pickle.STRING
+pickle.SliceType
+pickle.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+pickle.StringType
+pickle.StringTypes
+pickle.TRUE
+pickle.TUPLE
+pickle.TUPLE1
+pickle.TUPLE2
+pickle.TUPLE3
+pickle.TracebackType
+pickle.TupleType
+pickle.TypeType
+pickle.UNICODE
+pickle.UnboundMethodType
+pickle.UnicodeType
+pickle.Unpickler(??)
+pickle.UnpicklingError(??)
+pickle.XRangeType
+pickle.classmap
+pickle.compatible_formats
+pickle.decode_long(??)
+pickle.dispatch_table
+pickle.dump(??)
+pickle.dumps(??)
+pickle.encode_long(??)
+pickle.format_version
+pickle.load(??)
+pickle.loads(??)
+pickle.marshal
+pickle.mloads
+pickle.re
+pickle.struct
+pickle.sys
+pickle.warnings
+pickle.whichmodule(??)
+pickletools.ArgumentDescriptor
+pickletools.OpcodeInfo
+pickletools.StackObject
+pickletools.TAKEN_FROM_ARGUMENT1
+pickletools.TAKEN_FROM_ARGUMENT4
+pickletools.UP_TO_NEWLINE
+pickletools.anyobject
+pickletools.code2op
+pickletools.decimalnl_long
+pickletools.decimalnl_short
+pickletools.decode_long(??)
+pickletools.dis(??)
+pickletools.float8
+pickletools.floatnl
+pickletools.genops(??)
+pickletools.int4
+pickletools.long1
+pickletools.long4
+pickletools.markobject
+pickletools.opcodes
+pickletools.pybool
+pickletools.pydict
+pickletools.pyfloat
+pickletools.pyint
+pickletools.pyinteger_or_bool
+pickletools.pylist
+pickletools.pylong
+pickletools.pynone
+pickletools.pystring
+pickletools.pytuple
+pickletools.pyunicode
+pickletools.read_decimalnl_long(??)
+pickletools.read_decimalnl_short(??)
+pickletools.read_float8(??)
+pickletools.read_floatnl(??)
+pickletools.read_int4(??)
+pickletools.read_long1(??)
+pickletools.read_long4(??)
+pickletools.read_string1(??)
+pickletools.read_string4(??)
+pickletools.read_stringnl(??)
+pickletools.read_stringnl_noescape(??)
+pickletools.read_stringnl_noescape_pair(??)
+pickletools.read_uint1(??)
+pickletools.read_uint2(??)
+pickletools.read_unicodestring4(??)
+pickletools.read_unicodestringnl(??)
+pickletools.stackslice
+pickletools.string1
+pickletools.string4
+pickletools.stringnl
+pickletools.stringnl_noescape
+pickletools.stringnl_noescape_pair
+pickletools.uint1
+pickletools.uint2
+pickletools.unicodestring4
+pickletools.unicodestringnl
+pipes.FILEIN_FILEOUT
+pipes.FILEIN_STDOUT
+pipes.SINK
+pipes.SOURCE
+pipes.STDIN_FILEOUT
+pipes.STDIN_STDOUT
+pipes.Template(??)
+pipes.makepipeline(??)
+pipes.os
+pipes.quote(??)
+pipes.re
+pipes.stepkinds
+pipes.string
+pipes.tempfile
+pipes.test(??)
+pkgutil.extend_path(??)
+pkgutil.os
+pkgutil.sys
+platform.architecture(??)
+platform.dist(??)
+platform.java_ver(??)
+platform.libc_ver(??)
+platform.mac_ver(??)
+platform.machine(??)
+platform.node(??)
+platform.os
+platform.platform(??)
+platform.popen(??)
+platform.processor(??)
+platform.python_build(??)
+platform.python_compiler(??)
+platform.python_version(??)
+platform.python_version_tuple(??)
+platform.re
+platform.release(??)
+platform.string
+platform.sys
+platform.system(??)
+platform.system_alias(??)
+platform.uname(??)
+platform.version(??)
+platform.win32_ver(??)
+popen2.MAXFD
+popen2.Popen3(??)
+popen2.Popen4(??)
+popen2.os
+popen2.popen2(??)
+popen2.popen3(??)
+popen2.popen4(??)
+popen2.sys
+poplib.CR
+poplib.CRLF
+poplib.LF
+poplib.POP3(??)
+poplib.POP3_PORT
+poplib.POP3_SSL(??)
+poplib.POP3_SSL_PORT
+poplib.error_proto(??)
+poplib.re
+poplib.socket
+posix.EX_CANTCREAT
+posix.EX_CONFIG
+posix.EX_DATAERR
+posix.EX_IOERR
+posix.EX_NOHOST
+posix.EX_NOINPUT
+posix.EX_NOPERM
+posix.EX_NOUSER
+posix.EX_OK
+posix.EX_OSERR
+posix.EX_OSFILE
+posix.EX_PROTOCOL
+posix.EX_SOFTWARE
+posix.EX_TEMPFAIL
+posix.EX_UNAVAILABLE
+posix.EX_USAGE
+posix.F_OK
+posix.NGROUPS_MAX
+posix.O_APPEND
+posix.O_CREAT
+posix.O_DIRECT
+posix.O_DIRECTORY
+posix.O_DSYNC
+posix.O_EXCL
+posix.O_LARGEFILE
+posix.O_NDELAY
+posix.O_NOCTTY
+posix.O_NOFOLLOW
+posix.O_NONBLOCK
+posix.O_RDONLY
+posix.O_RDWR
+posix.O_RSYNC
+posix.O_SYNC
+posix.O_TRUNC
+posix.O_WRONLY
+posix.R_OK
+posix.TMP_MAX
+posix.WCONTINUED
+posix.WCOREDUMP(status) -> bool
+posix.WEXITSTATUS(status) -> integer
+posix.WIFCONTINUED(status) -> bool
+posix.WIFEXITED(status) -> bool
+posix.WIFSIGNALED(status) -> bool
+posix.WIFSTOPPED(status) -> bool
+posix.WNOHANG
+posix.WSTOPSIG(status) -> integer
+posix.WTERMSIG(status) -> integer
+posix.WUNTRACED
+posix.W_OK
+posix.X_OK
+posix.abort() -> does not return!
+posix.access(path, mode) -> 1 if granted, 0 otherwise
+posix.chdir(path)
+posix.chmod(path, mode)
+posix.chown(path, uid, gid)
+posix.chroot(path)
+posix.close(fd)
+posix.confstr(name) -> string
+posix.confstr_names
+posix.ctermid() -> string
+posix.dup(fd) -> fd2
+posix.dup2(old_fd, new_fd)
+posix.environ
+posix.error(??)
+posix.execv(path, args)
+posix.execve(path, args, env)
+posix.fchdir(fildes)
+posix.fdatasync(fildes)
+posix.fdopen(fd [, mode='r' [, bufsize]]) -> file_object
+posix.fork() -> pid
+posix.forkpty() -> (pid, master_fd)
+posix.fpathconf(fd, name) -> integer
+posix.fstat(fd) -> stat result
+posix.fstatvfs(fd) -> statvfs result
+posix.fsync(fildes)
+posix.ftruncate(fd, length)
+posix.getcwd() -> path
+posix.getcwdu() -> path
+posix.getegid() -> egid
+posix.geteuid() -> euid
+posix.getgid() -> gid
+posix.getgroups() -> list of group IDs
+posix.getloadavg() -> (float, float, float)
+posix.getlogin() -> string
+posix.getpgid(pid) -> pgid
+posix.getpgrp() -> pgrp
+posix.getpid() -> pid
+posix.getppid() -> ppid
+posix.getsid(pid) -> sid
+posix.getuid() -> uid
+posix.isatty(fd) -> bool
+posix.kill(pid, sig)
+posix.killpg(pgid, sig)
+posix.lchown(path, uid, gid)
+posix.link(src, dst)
+posix.listdir(path) -> list_of_strings
+posix.lseek(fd, pos, how) -> newpos
+posix.lstat(path) -> stat result
+posix.major(device) -> major number
+posix.makedev(major, minor) -> device number
+posix.minor(device) -> minor number
+posix.mkdir(path [, mode=0777])
+posix.mkfifo(filename [, mode=0666])
+posix.mknod(filename [, mode=0600, device])
+posix.nice(inc) -> new_priority
+posix.open(filename, flag [, mode=0777]) -> fd
+posix.openpty() -> (master_fd, slave_fd)
+posix.pathconf(path, name) -> integer
+posix.pathconf_names
+posix.pipe() -> (read_end, write_end)
+posix.popen(command [, mode='r' [, bufsize]]) -> pipe
+posix.putenv(key, value)
+posix.read(fd, buffersize) -> string
+posix.readlink(path) -> path
+posix.remove(path)
+posix.rename(old, new)
+posix.rmdir(path)
+posix.setegid(gid)
+posix.seteuid(uid)
+posix.setgid(gid)
+posix.setgroups(list)
+posix.setpgid(pid, pgrp)
+posix.setpgrp()
+posix.setregid(rgid, egid)
+posix.setreuid(ruid, euid)
+posix.setsid()
+posix.setuid(uid)
+posix.stat(path) -> stat result
+posix.stat_float_times([newval]) -> oldval
+posix.stat_result
+posix.statvfs(path) -> statvfs result
+posix.statvfs_result
+posix.strerror(code) -> string
+posix.symlink(src, dst)
+posix.sysconf(name) -> integer
+posix.sysconf_names
+posix.system(command) -> exit_status
+posix.tcgetpgrp(fd) -> pgid
+posix.tcsetpgrp(fd, pgid)
+posix.tempnam([dir[, prefix]]) -> string
+posix.times() -> (utime, stime, cutime, cstime, elapsed_time)
+posix.tmpfile() -> file object
+posix.tmpnam() -> string
+posix.ttyname(fd) -> string
+posix.umask(new_mask) -> old_mask
+posix.uname() -> (sysname, nodename, release, version, machine)
+posix.unlink(path)
+posix.unsetenv(key)
+posix.utime(path, (atime, utime))
+posix.wait() -> (pid, status)
+posix.waitpid(pid, options) -> (pid, status)
+posix.write(fd, string) -> byteswritten
+posixfile.SEEK_CUR
+posixfile.SEEK_END
+posixfile.SEEK_SET
+posixfile.fileopen(??)
+posixfile.open(??)
+posixpath.abspath(??)
+posixpath.altsep
+posixpath.basename(??)
+posixpath.commonprefix(??)
+posixpath.curdir
+posixpath.defpath
+posixpath.devnull
+posixpath.dirname(??)
+posixpath.exists(??)
+posixpath.expanduser(??)
+posixpath.expandvars(??)
+posixpath.extsep
+posixpath.getatime(??)
+posixpath.getctime(??)
+posixpath.getmtime(??)
+posixpath.getsize(??)
+posixpath.isabs(??)
+posixpath.isdir(??)
+posixpath.isfile(??)
+posixpath.islink(??)
+posixpath.ismount(??)
+posixpath.join(??)
+posixpath.lexists(??)
+posixpath.normcase(??)
+posixpath.normpath(??)
+posixpath.os
+posixpath.pardir
+posixpath.pathsep
+posixpath.realpath(??)
+posixpath.samefile(??)
+posixpath.sameopenfile(??)
+posixpath.samestat(??)
+posixpath.sep
+posixpath.split(??)
+posixpath.splitdrive(??)
+posixpath.splitext(??)
+posixpath.stat
+posixpath.supports_unicode_filenames
+posixpath.walk(??)
+pow(x, y[, z]) -> number
+pprint.PrettyPrinter(??)
+pprint.isreadable(??)
+pprint.isrecursive(??)
+pprint.pformat(??)
+pprint.pprint(??)
+pprint.saferepr(??)
+profile.OptionParser(??)
+profile.Profile(??)
+profile.Stats(??)
+profile.help(??)
+profile.marshal
+profile.os
+profile.run(??)
+profile.runctx(??)
+profile.sys
+profile.time
+property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
+pstats.Stats(??)
+pstats.TupleComp(??)
+pstats.add_callers(??)
+pstats.add_func_stats(??)
+pstats.count_calls(??)
+pstats.f8(??)
+pstats.func_get_function_name(??)
+pstats.func_std_string(??)
+pstats.func_strip_path(??)
+pstats.marshal
+pstats.os
+pstats.re
+pstats.time
+pty.CHILD
+pty.STDERR_FILENO
+pty.STDIN_FILENO
+pty.STDOUT_FILENO
+pty.fork() -> (pid, master_fd)
+pty.master_open() -> (master_fd, slave_name)
+pty.openpty() -> (master_fd, slave_fd)
+pty.os
+pty.select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)
+pty.slave_open(tty_name) -> slave_fd
+pty.spawn(??)
+pty.tty
+pwd.getpwall() -> list_of_entries
+pwd.getpwnam(name) -> (pw_name,pw_passwd,pw_uid,
+pwd.getpwuid(uid) -> (pw_name,pw_passwd,pw_uid,
+pwd.struct_passwd
+pwd.struct_pwent
+py_compile.MAGIC
+py_compile.PyCompileError(??)
+py_compile.compile(??)
+py_compile.imp
+py_compile.main(??)
+py_compile.marshal
+py_compile.os
+py_compile.set_creator_type(??)
+py_compile.sys
+py_compile.traceback
+py_compile.wr_long(??)
+pyclbr.Class(??)
+pyclbr.DEDENT
+pyclbr.Function(??)
+pyclbr.NAME
+pyclbr.NEWLINE
+pyclbr.imp
+pyclbr.itemgetter(item) --> itemgetter object
+pyclbr.readmodule(??)
+pyclbr.readmodule_ex(??)
+pyclbr.sys
+pyclbr.tokenize
+pydoc.Doc(??)
+pydoc.ErrorDuringImport(??)
+pydoc.HTMLDoc(??)
+pydoc.HTMLRepr(??)
+pydoc.Helper(??)
+pydoc.ModuleScanner(??)
+pydoc.Repr(??)
+pydoc.Scanner(??)
+pydoc.TextDoc(??)
+pydoc.TextRepr(??)
+pydoc.allmethods(??)
+pydoc.apropos(??)
+pydoc.classname(??)
+pydoc.cli(??)
+pydoc.cram(??)
+pydoc.deque(iterable) --> deque object
+pydoc.describe(??)
+pydoc.doc(??)
+pydoc.expandtabs(s [,tabsize]) -> string
+pydoc.find(s, sub [,start [,end]]) -> in
+pydoc.getdoc(??)
+pydoc.getpager(??)
+pydoc.gui(??)
+pydoc.help
+pydoc.html
+pydoc.imp
+pydoc.importfile(??)
+pydoc.inspect
+pydoc.isdata(??)
+pydoc.ispackage(??)
+pydoc.ispath(??)
+pydoc.join(list [,sep]) -> string
+pydoc.locate(??)
+pydoc.lower(s) -> string
+pydoc.os
+pydoc.pager(??)
+pydoc.pathdirs(??)
+pydoc.pipepager(??)
+pydoc.plain(??)
+pydoc.plainpager(??)
+pydoc.re
+pydoc.replace(??)
+pydoc.resolve(??)
+pydoc.rfind(s, sub [,start [,end]]) -> int
+pydoc.rstrip(s [,chars]) -> string
+pydoc.safeimport(??)
+pydoc.serve(??)
+pydoc.split(s [,sep [,maxsplit]]) -> list of strings
+pydoc.splitdoc(??)
+pydoc.strip(s [,chars]) -> string
+pydoc.stripid(??)
+pydoc.synopsis(??)
+pydoc.sys
+pydoc.tempfilepager(??)
+pydoc.text
+pydoc.ttypager(??)
+pydoc.types
+pydoc.visiblename(??)
+pydoc.writedoc(??)
+pydoc.writedocs(??)
+pyexpat.EXPAT_VERSION
+pyexpat.ErrorString(errno) -> string
+pyexpat.ExpatError(??)
+pyexpat.ParserCreate([encoding[, namespace_separator]]) -> parser
+pyexpat.XMLParserType
+pyexpat.XML_PARAM_ENTITY_PARSING_ALWAYS
+pyexpat.XML_PARAM_ENTITY_PARSING_NEVER
+pyexpat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
+pyexpat.error(??)
+pyexpat.errors
+pyexpat.features
+pyexpat.model
+pyexpat.native_encoding
+pyexpat.version_info
+quit
+quopri.EMPTYSTRING
+quopri.ESCAPE
+quopri.HEX
+quopri.MAXLINESIZE
+quopri.a2b_qp
+quopri.b2a_qp(data, quotetabs=0, istext=1, header=0) -> s;
+quopri.decode(??)
+quopri.decodestring(??)
+quopri.encode(??)
+quopri.encodestring(??)
+quopri.ishex(??)
+quopri.main(??)
+quopri.needsquoting(??)
+quopri.quote(??)
+quopri.unhex(??)
+random.BPF
+random.LOG4
+random.NV_MAGICCONST
+random.RECIP_BPF
+random.Random
+random.SG_MAGICCONST
+random.SystemRandom
+random.TWOPI
+random.WichmannHill
+random.betavariate
+random.choice
+random.expovariate
+random.gammavariate
+random.gauss
+random.getrandbits(k) -> x.  Generates a long int with k random bits.
+random.getstate
+random.jumpahead(int) -> None.  Create new state from existing state and integer.
+random.lognormvariate
+random.normalvariate
+random.paretovariate
+random.randint
+random.random() -> x in the interval [0, 1).
+random.randrange
+random.sample
+random.seed
+random.setstate
+random.shuffle
+random.uniform
+random.vonmisesvariate
+random.weibullvariate
+range([start,] stop[, step]) -> list of integers
+raw_input([prompt]) -> string
+re.DOTALL
+re.I
+re.IGNORECASE
+re.L
+re.LOCALE
+re.M
+re.MULTILINE
+re.S
+re.U
+re.UNICODE
+re.VERBOSE
+re.X
+re.compile(??)
+re.engine
+re.error(??)
+re.escape(??)
+re.findall(??)
+re.finditer(??)
+re.match(??)
+re.purge(??)
+re.search(??)
+re.split(??)
+re.sub(??)
+re.subn(??)
+re.template(??)
+readline.add_history(string) -> None
+readline.clear_history() -> None
+readline.get_begidx() -> int
+readline.get_completer() -> function
+readline.get_completer_delims() -> string
+readline.get_current_history_length() -> integer
+readline.get_endidx() -> int
+readline.get_history_item() -> string
+readline.get_history_length() -> int
+readline.get_line_buffer() -> string
+readline.insert_text(string) -> None
+readline.parse_and_bind(string) -> None
+readline.read_history_file([filename]) -> None
+readline.read_init_file([filename]) -> None
+readline.redisplay() -> None
+readline.remove_history_item(pos) -> None
+readline.replace_history_item(pos, line) -> None
+readline.set_completer([function]) -> None
+readline.set_completer_delims(string) -> None
+readline.set_history_length(length) -> None
+readline.set_startup_hook([function]) -> None
+readline.write_history_file([filename]) -> None
+reconvert.RE_ANSI_HEX
+reconvert.RE_BK_PLUS_QM
+reconvert.RE_CONTEXT_INDEP_OPS
+reconvert.RE_NEWLINE_OR
+reconvert.RE_NO_BK_PARENS
+reconvert.RE_NO_BK_VBAR
+reconvert.RE_NO_GNU_EXTENSIONS
+reconvert.RE_SYNTAX_AWK
+reconvert.RE_SYNTAX_EGREP
+reconvert.RE_SYNTAX_EMACS
+reconvert.RE_SYNTAX_GREP
+reconvert.RE_TIGHT_VBAR
+reconvert.convert(??)
+reconvert.main(??)
+reconvert.mastertable
+reconvert.quote(??)
+reconvert.regex
+reconvert.warnings
+reduce(function, sequence[, initial]) -> value
+regex.casefold
+regex.compile
+regex.error(??)
+regex.get_syntax
+regex.match
+regex.search
+regex.set_syntax
+regex.symcomp
+regex_syntax.RE_ANSI_HEX
+regex_syntax.RE_BK_PLUS_QM
+regex_syntax.RE_CONTEXT_INDEP_OPS
+regex_syntax.RE_NEWLINE_OR
+regex_syntax.RE_NO_BK_PARENS
+regex_syntax.RE_NO_BK_VBAR
+regex_syntax.RE_NO_GNU_EXTENSIONS
+regex_syntax.RE_SYNTAX_AWK
+regex_syntax.RE_SYNTAX_EGREP
+regex_syntax.RE_SYNTAX_EMACS
+regex_syntax.RE_SYNTAX_GREP
+regex_syntax.RE_TIGHT_VBAR
+regsub.cache
+regsub.capwords(??)
+regsub.clear_cache(??)
+regsub.compile(??)
+regsub.expand(??)
+regsub.gsub(??)
+regsub.intsplit(??)
+regsub.regex
+regsub.split(??)
+regsub.splitx(??)
+regsub.sub(??)
+regsub.test(??)
+regsub.warnings
+reload(module) -> module
+repr(object) -> string
+repr.Repr(??)
+repr.aRepr
+repr.islice(iterable, [start,] stop [, step]) --> islice object
+repr.repr
+resource.RLIMIT_AS
+resource.RLIMIT_CORE
+resource.RLIMIT_CPU
+resource.RLIMIT_DATA
+resource.RLIMIT_FSIZE
+resource.RLIMIT_MEMLOCK
+resource.RLIMIT_NOFILE
+resource.RLIMIT_NPROC
+resource.RLIMIT_OFILE
+resource.RLIMIT_RSS
+resource.RLIMIT_STACK
+resource.RLIM_INFINITY
+resource.RUSAGE_CHILDREN
+resource.RUSAGE_SELF
+resource.error(??)
+resource.getpagesize
+resource.getrlimit
+resource.getrusage
+resource.setrlimit
+resource.struct_rusage
+reversed(sequence) -> reverse iterator over values of the sequence
+rexec.FileBase(??)
+rexec.FileDelegate(??)
+rexec.FileWrapper(??)
+rexec.RExec(??)
+rexec.RHooks(??)
+rexec.RModuleImporter(??)
+rexec.RModuleLoader(??)
+rexec.TEMPLATE
+rexec.ihooks
+rexec.imp
+rexec.os
+rexec.sys
+rexec.test(??)
+rfc822.AddressList(??)
+rfc822.AddrlistClass(??)
+rfc822.Message(??)
+rfc822.dump_address_pair(??)
+rfc822.formatdate(??)
+rfc822.mktime_tz(??)
+rfc822.parseaddr(??)
+rfc822.parsedate(??)
+rfc822.parsedate_tz(??)
+rfc822.quote(??)
+rfc822.time
+rfc822.unquote(??)
+rlcompleter.Completer(??)
+rlcompleter.get_class_members(??)
+rlcompleter.readline
+robotparser.Entry(??)
+robotparser.RobotFileParser(??)
+robotparser.RuleLine(??)
+robotparser.URLopener(??)
+robotparser.debug
+robotparser.urllib
+robotparser.urlparse
+round(number[, ndigits]) -> floating point number
+sched.bisect
+sched.scheduler(??)
+select.POLLERR
+select.POLLHUP
+select.POLLIN
+select.POLLMSG
+select.POLLNVAL
+select.POLLOUT
+select.POLLPRI
+select.POLLRDBAND
+select.POLLRDNORM
+select.POLLWRBAND
+select.POLLWRNORM
+select.error(??)
+select.poll
+select.select(rlist, wlist, xlist[, timeout]) -> (rlist, wlist, xlist)
+set(iterable) --> set object
+setattr(object, name, value)
+sets.BaseSet
+sets.ImmutableSet
+sets.Set
+sets.generators
+sets.ifilter(function or None, sequence) --> ifilter object
+sets.ifilterfalse(function or None, sequence) --> ifilterfalse object
+sgmllib.SGMLParseError(??)
+sgmllib.SGMLParser(??)
+sgmllib.TestSGMLParser(??)
+sgmllib.attrfind
+sgmllib.charref
+sgmllib.endbracket
+sgmllib.entityref
+sgmllib.incomplete
+sgmllib.interesting
+sgmllib.markupbase
+sgmllib.piclose
+sgmllib.re
+sgmllib.shorttag
+sgmllib.shorttagopen
+sgmllib.starttagopen
+sgmllib.tagfind
+sgmllib.test(??)
+sha.blocksize
+sha.digest_size
+sha.digestsize
+sha.new
+sha.sha
+shelve.BsdDbShelf(??)
+shelve.DbfilenameShelf(??)
+shelve.Pickler(file, protocol=0) -- Create a pickler.
+shelve.Shelf(??)
+shelve.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+shelve.Unpickler(file) -- Create an unpickler.
+shelve.UserDict
+shelve.open(??)
+shelve.warnings
+shlex.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+shlex.deque(iterable) --> deque object
+shlex.os
+shlex.shlex(??)
+shlex.split(??)
+shlex.sys
+shutil.Error(??)
+shutil.abspath(??)
+shutil.copy(??)
+shutil.copy2(??)
+shutil.copyfile(??)
+shutil.copyfileobj(??)
+shutil.copymode(??)
+shutil.copystat(??)
+shutil.copytree(??)
+shutil.destinsrc(??)
+shutil.exceptions
+shutil.move(??)
+shutil.os
+shutil.rmtree(??)
+shutil.stat
+shutil.sys
+signal.NSIG
+signal.SIGABRT
+signal.SIGALRM
+signal.SIGBUS
+signal.SIGCHLD
+signal.SIGCLD
+signal.SIGCONT
+signal.SIGFPE
+signal.SIGHUP
+signal.SIGILL
+signal.SIGINT
+signal.SIGIO
+signal.SIGIOT
+signal.SIGKILL
+signal.SIGPIPE
+signal.SIGPOLL
+signal.SIGPROF
+signal.SIGPWR
+signal.SIGQUIT
+signal.SIGRTMAX
+signal.SIGRTMIN
+signal.SIGSEGV
+signal.SIGSTOP
+signal.SIGSYS
+signal.SIGTERM
+signal.SIGTRAP
+signal.SIGTSTP
+signal.SIGTTIN
+signal.SIGTTOU
+signal.SIGURG
+signal.SIGUSR1
+signal.SIGUSR2
+signal.SIGVTALRM
+signal.SIGWINCH
+signal.SIGXCPU
+signal.SIGXFSZ
+signal.SIG_DFL
+signal.SIG_IGN
+signal.alarm(seconds)
+signal.default_int_handler(...)
+signal.getsignal(sig) -> action
+signal.pause()
+signal.signal(sig, action) -> action
+site.abs__file__(??)
+site.addbuilddir(??)
+site.addpackage(??)
+site.addsitedir(??)
+site.addsitepackages(??)
+site.aliasmbcs(??)
+site.execsitecustomize(??)
+site.main(??)
+site.makepath(??)
+site.os
+site.removeduppaths(??)
+site.setBEGINLIBPATH(??)
+site.setcopyright(??)
+site.setencoding(??)
+site.sethelper(??)
+site.setquit(??)
+site.sys
+slice([start,] stop[, step])
+smtpd.COMMASPACE
+smtpd.DEBUGSTREAM
+smtpd.DebuggingServer(??)
+smtpd.Devnull(??)
+smtpd.EMPTYSTRING
+smtpd.MailmanProxy(??)
+smtpd.NEWLINE
+smtpd.Options(??)
+smtpd.PureProxy(??)
+smtpd.SMTPChannel(??)
+smtpd.SMTPServer(??)
+smtpd.asynchat
+smtpd.asyncore
+smtpd.errno
+smtpd.getopt
+smtpd.os
+smtpd.parseargs(??)
+smtpd.program
+smtpd.socket
+smtpd.sys
+smtpd.time
+smtpd.usage(??)
+smtplib.CRLF
+smtplib.OLDSTYLE_AUTH
+smtplib.SMTP(??)
+smtplib.SMTPAuthenticationError(??)
+smtplib.SMTPConnectError(??)
+smtplib.SMTPDataError(??)
+smtplib.SMTPException(??)
+smtplib.SMTPHeloError(??)
+smtplib.SMTPRecipientsRefused(??)
+smtplib.SMTPResponseException(??)
+smtplib.SMTPSenderRefused(??)
+smtplib.SMTPServerDisconnected(??)
+smtplib.SMTP_PORT
+smtplib.SSLFakeFile(??)
+smtplib.SSLFakeSocket(??)
+smtplib.base64
+smtplib.encode_base64(??)
+smtplib.hmac
+smtplib.quoteaddr(??)
+smtplib.quotedata(??)
+smtplib.re
+smtplib.rfc822
+smtplib.socket
+smtplib.stderr
+sndhdr.get_long_be(??)
+sndhdr.get_long_le(??)
+sndhdr.get_short_be(??)
+sndhdr.get_short_le(??)
+sndhdr.test(??)
+sndhdr.test_8svx(??)
+sndhdr.test_aifc(??)
+sndhdr.test_au(??)
+sndhdr.test_hcom(??)
+sndhdr.test_sndr(??)
+sndhdr.test_sndt(??)
+sndhdr.test_voc(??)
+sndhdr.test_wav(??)
+sndhdr.testall(??)
+sndhdr.tests
+sndhdr.what(??)
+sndhdr.whathdr(??)
+socket.AF_APPLETALK
+socket.AF_ASH
+socket.AF_ATMPVC
+socket.AF_ATMSVC
+socket.AF_AX25
+socket.AF_BRIDGE
+socket.AF_DECnet
+socket.AF_ECONET
+socket.AF_INET
+socket.AF_INET6
+socket.AF_IPX
+socket.AF_IRDA
+socket.AF_KEY
+socket.AF_NETBEUI
+socket.AF_NETLINK
+socket.AF_NETROM
+socket.AF_PACKET
+socket.AF_PPPOX
+socket.AF_ROSE
+socket.AF_ROUTE
+socket.AF_SECURITY
+socket.AF_SNA
+socket.AF_UNIX
+socket.AF_UNSPEC
+socket.AF_WANPIPE
+socket.AF_X25
+socket.AI_ADDRCONFIG
+socket.AI_ALL
+socket.AI_CANONNAME
+socket.AI_NUMERICHOST
+socket.AI_NUMERICSERV
+socket.AI_PASSIVE
+socket.AI_V4MAPPED
+socket.CAPI
+socket.EAI_ADDRFAMILY
+socket.EAI_AGAIN
+socket.EAI_BADFLAGS
+socket.EAI_FAIL
+socket.EAI_FAMILY
+socket.EAI_MEMORY
+socket.EAI_NODATA
+socket.EAI_NONAME
+socket.EAI_OVERFLOW
+socket.EAI_SERVICE
+socket.EAI_SOCKTYPE
+socket.EAI_SYSTEM
+socket.EBADF
+socket.INADDR_ALLHOSTS_GROUP
+socket.INADDR_ANY
+socket.INADDR_BROADCAST
+socket.INADDR_LOOPBACK
+socket.INADDR_MAX_LOCAL_GROUP
+socket.INADDR_NONE
+socket.INADDR_UNSPEC_GROUP
+socket.IPPORT_RESERVED
+socket.IPPORT_USERRESERVED
+socket.IPPROTO_AH
+socket.IPPROTO_DSTOPTS
+socket.IPPROTO_EGP
+socket.IPPROTO_ESP
+socket.IPPROTO_FRAGMENT
+socket.IPPROTO_GRE
+socket.IPPROTO_HOPOPTS
+socket.IPPROTO_ICMP
+socket.IPPROTO_ICMPV6
+socket.IPPROTO_IDP
+socket.IPPROTO_IGMP
+socket.IPPROTO_IP
+socket.IPPROTO_IPIP
+socket.IPPROTO_IPV6
+socket.IPPROTO_NONE
+socket.IPPROTO_PIM
+socket.IPPROTO_PUP
+socket.IPPROTO_RAW
+socket.IPPROTO_ROUTING
+socket.IPPROTO_RSVP
+socket.IPPROTO_TCP
+socket.IPPROTO_TP
+socket.IPPROTO_UDP
+socket.IPV6_CHECKSUM
+socket.IPV6_DSTOPTS
+socket.IPV6_HOPLIMIT
+socket.IPV6_HOPOPTS
+socket.IPV6_JOIN_GROUP
+socket.IPV6_LEAVE_GROUP
+socket.IPV6_MULTICAST_HOPS
+socket.IPV6_MULTICAST_IF
+socket.IPV6_MULTICAST_LOOP
+socket.IPV6_NEXTHOP
+socket.IPV6_PKTINFO
+socket.IPV6_RECVDSTOPTS
+socket.IPV6_RECVHOPLIMIT
+socket.IPV6_RECVHOPOPTS
+socket.IPV6_RECVPKTINFO
+socket.IPV6_RECVRTHDR
+socket.IPV6_RECVTCLASS
+socket.IPV6_RTHDR
+socket.IPV6_RTHDRDSTOPTS
+socket.IPV6_RTHDR_TYPE_0
+socket.IPV6_TCLASS
+socket.IPV6_UNICAST_HOPS
+socket.IPV6_V6ONLY
+socket.IP_ADD_MEMBERSHIP
+socket.IP_DEFAULT_MULTICAST_LOOP
+socket.IP_DEFAULT_MULTICAST_TTL
+socket.IP_DROP_MEMBERSHIP
+socket.IP_HDRINCL
+socket.IP_MAX_MEMBERSHIPS
+socket.IP_MULTICAST_IF
+socket.IP_MULTICAST_LOOP
+socket.IP_MULTICAST_TTL
+socket.IP_OPTIONS
+socket.IP_RECVOPTS
+socket.IP_RECVRETOPTS
+socket.IP_RETOPTS
+socket.IP_TOS
+socket.IP_TTL
+socket.MSG_CTRUNC
+socket.MSG_DONTROUTE
+socket.MSG_DONTWAIT
+socket.MSG_EOR
+socket.MSG_OOB
+socket.MSG_PEEK
+socket.MSG_TRUNC
+socket.MSG_WAITALL
+socket.NI_DGRAM
+socket.NI_MAXHOST
+socket.NI_MAXSERV
+socket.NI_NAMEREQD
+socket.NI_NOFQDN
+socket.NI_NUMERICHOST
+socket.NI_NUMERICSERV
+socket.PACKET_BROADCAST
+socket.PACKET_FASTROUTE
+socket.PACKET_HOST
+socket.PACKET_LOOPBACK
+socket.PACKET_MULTICAST
+socket.PACKET_OTHERHOST
+socket.PACKET_OUTGOING
+socket.PF_PACKET
+socket.RAND_add(string, entropy)
+socket.RAND_egd(path) -> bytes
+socket.RAND_status() -> 0 or 1
+socket.SHUT_RD
+socket.SHUT_RDWR
+socket.SHUT_WR
+socket.SOCK_DGRAM
+socket.SOCK_RAW
+socket.SOCK_RDM
+socket.SOCK_SEQPACKET
+socket.SOCK_STREAM
+socket.SOL_IP
+socket.SOL_SOCKET
+socket.SOL_TCP
+socket.SOL_UDP
+socket.SOMAXCONN
+socket.SO_ACCEPTCONN
+socket.SO_BROADCAST
+socket.SO_DEBUG
+socket.SO_DONTROUTE
+socket.SO_ERROR
+socket.SO_KEEPALIVE
+socket.SO_LINGER
+socket.SO_OOBINLINE
+socket.SO_RCVBUF
+socket.SO_RCVLOWAT
+socket.SO_RCVTIMEO
+socket.SO_REUSEADDR
+socket.SO_SNDBUF
+socket.SO_SNDLOWAT
+socket.SO_SNDTIMEO
+socket.SO_TYPE
+socket.SSLType
+socket.SSL_ERROR_EOF
+socket.SSL_ERROR_INVALID_ERROR_CODE
+socket.SSL_ERROR_SSL
+socket.SSL_ERROR_SYSCALL
+socket.SSL_ERROR_WANT_CONNECT
+socket.SSL_ERROR_WANT_READ
+socket.SSL_ERROR_WANT_WRITE
+socket.SSL_ERROR_WANT_X509_LOOKUP
+socket.SSL_ERROR_ZERO_RETURN
+socket.SocketType
+socket.TCP_CORK
+socket.TCP_DEFER_ACCEPT
+socket.TCP_INFO
+socket.TCP_KEEPCNT
+socket.TCP_KEEPIDLE
+socket.TCP_KEEPINTVL
+socket.TCP_LINGER2
+socket.TCP_MAXSEG
+socket.TCP_NODELAY
+socket.TCP_QUICKACK
+socket.TCP_SYNCNT
+socket.TCP_WINDOW_CLAMP
+socket.error(??)
+socket.fromfd(fd, family, type[, proto]) -> socket object
+socket.gaierror(??)
+socket.getaddrinfo(host, port [, family, socktype, proto, flags])
+socket.getdefaulttimeout() -> timeout
+socket.getfqdn(??)
+socket.gethostbyaddr(host) -> (name, aliaslist, addresslist)
+socket.gethostbyname(host) -> address
+socket.gethostbyname_ex(host) -> (name, aliaslist, addresslist)
+socket.gethostname() -> string
+socket.getnameinfo(sockaddr, flags) --> (host, port)
+socket.getprotobyname(name) -> integer
+socket.getservbyname(servicename[, protocolname]) -> integer
+socket.getservbyport(port[, protocolname]) -> string
+socket.has_ipv6
+socket.herror(??)
+socket.htonl(integer) -> integer
+socket.htons(integer) -> integer
+socket.inet_aton(string) -> packed 32-bit IP representation
+socket.inet_ntoa(packed_ip) -> ip_address_string
+socket.inet_ntop(af, packed_ip) -> string formatted IP address
+socket.inet_pton(af, ip) -> packed IP address string
+socket.ntohl(integer) -> integer
+socket.ntohs(integer) -> integer
+socket.os
+socket.setdefaulttimeout(timeout)
+socket.socket([family[, type[, proto]]]) -> socket object
+socket.socketpair([family[, type[, proto]]]) -> (socket object, socket object)
+socket.ssl(??)
+socket.sslerror(??)
+socket.sys
+socket.timeout(??)
+sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
+sre.DEBUG
+sre.DOTALL
+sre.I
+sre.IGNORECASE
+sre.L
+sre.LOCALE
+sre.M
+sre.MULTILINE
+sre.S
+sre.Scanner(??)
+sre.T
+sre.TEMPLATE
+sre.U
+sre.UNICODE
+sre.VERBOSE
+sre.X
+sre.compile(??)
+sre.copy_reg
+sre.error(??)
+sre.escape(??)
+sre.findall(??)
+sre.finditer(??)
+sre.match(??)
+sre.purge(??)
+sre.search(??)
+sre.split(??)
+sre.sre_compile
+sre.sre_parse
+sre.sub(??)
+sre.subn(??)
+sre.sys
+sre.template(??)
+sre_compile.ANY
+sre_compile.ANY_ALL
+sre_compile.ASSERT
+sre_compile.ASSERT_NOT
+sre_compile.AT
+sre_compile.ATCODES
+sre_compile.AT_BEGINNING
+sre_compile.AT_BEGINNING_LINE
+sre_compile.AT_BEGINNING_STRING
+sre_compile.AT_BOUNDARY
+sre_compile.AT_END
+sre_compile.AT_END_LINE
+sre_compile.AT_END_STRING
+sre_compile.AT_LOCALE
+sre_compile.AT_LOC_BOUNDARY
+sre_compile.AT_LOC_NON_BOUNDARY
+sre_compile.AT_MULTILINE
+sre_compile.AT_NON_BOUNDARY
+sre_compile.AT_UNICODE
+sre_compile.AT_UNI_BOUNDARY
+sre_compile.AT_UNI_NON_BOUNDARY
+sre_compile.BIGCHARSET
+sre_compile.BRANCH
+sre_compile.CALL
+sre_compile.CATEGORY
+sre_compile.CATEGORY_DIGIT
+sre_compile.CATEGORY_LINEBREAK
+sre_compile.CATEGORY_LOC_NOT_WORD
+sre_compile.CATEGORY_LOC_WORD
+sre_compile.CATEGORY_NOT_DIGIT
+sre_compile.CATEGORY_NOT_LINEBREAK
+sre_compile.CATEGORY_NOT_SPACE
+sre_compile.CATEGORY_NOT_WORD
+sre_compile.CATEGORY_SPACE
+sre_compile.CATEGORY_UNI_DIGIT
+sre_compile.CATEGORY_UNI_LINEBREAK
+sre_compile.CATEGORY_UNI_NOT_DIGIT
+sre_compile.CATEGORY_UNI_NOT_LINEBREAK
+sre_compile.CATEGORY_UNI_NOT_SPACE
+sre_compile.CATEGORY_UNI_NOT_WORD
+sre_compile.CATEGORY_UNI_SPACE
+sre_compile.CATEGORY_UNI_WORD
+sre_compile.CATEGORY_WORD
+sre_compile.CHARSET
+sre_compile.CHCODES
+sre_compile.CH_LOCALE
+sre_compile.CH_UNICODE
+sre_compile.FAILURE
+sre_compile.GROUPREF
+sre_compile.GROUPREF_EXISTS
+sre_compile.GROUPREF_IGNORE
+sre_compile.IN
+sre_compile.INFO
+sre_compile.IN_IGNORE
+sre_compile.JUMP
+sre_compile.LITERAL
+sre_compile.LITERAL_IGNORE
+sre_compile.MAGIC
+sre_compile.MARK
+sre_compile.MAXCODE
+sre_compile.MAXREPEAT
+sre_compile.MAX_REPEAT
+sre_compile.MAX_UNTIL
+sre_compile.MIN_REPEAT
+sre_compile.MIN_REPEAT_ONE
+sre_compile.MIN_UNTIL
+sre_compile.NEGATE
+sre_compile.NOT_LITERAL
+sre_compile.NOT_LITERAL_IGNORE
+sre_compile.OPCODES
+sre_compile.OP_IGNORE
+sre_compile.RANGE
+sre_compile.REPEAT
+sre_compile.REPEAT_ONE
+sre_compile.SRE_FLAG_DEBUG
+sre_compile.SRE_FLAG_DOTALL
+sre_compile.SRE_FLAG_IGNORECASE
+sre_compile.SRE_FLAG_LOCALE
+sre_compile.SRE_FLAG_MULTILINE
+sre_compile.SRE_FLAG_TEMPLATE
+sre_compile.SRE_FLAG_UNICODE
+sre_compile.SRE_FLAG_VERBOSE
+sre_compile.SRE_INFO_CHARSET
+sre_compile.SRE_INFO_LITERAL
+sre_compile.SRE_INFO_PREFIX
+sre_compile.STRING_TYPES
+sre_compile.SUBPATTERN
+sre_compile.SUCCESS
+sre_compile.compile(??)
+sre_compile.error(??)
+sre_compile.isstring(??)
+sre_compile.makedict(??)
+sre_compile.sys
+sre_constants.ANY
+sre_constants.ANY_ALL
+sre_constants.ASSERT
+sre_constants.ASSERT_NOT
+sre_constants.AT
+sre_constants.ATCODES
+sre_constants.AT_BEGINNING
+sre_constants.AT_BEGINNING_LINE
+sre_constants.AT_BEGINNING_STRING
+sre_constants.AT_BOUNDARY
+sre_constants.AT_END
+sre_constants.AT_END_LINE
+sre_constants.AT_END_STRING
+sre_constants.AT_LOCALE
+sre_constants.AT_LOC_BOUNDARY
+sre_constants.AT_LOC_NON_BOUNDARY
+sre_constants.AT_MULTILINE
+sre_constants.AT_NON_BOUNDARY
+sre_constants.AT_UNICODE
+sre_constants.AT_UNI_BOUNDARY
+sre_constants.AT_UNI_NON_BOUNDARY
+sre_constants.BIGCHARSET
+sre_constants.BRANCH
+sre_constants.CALL
+sre_constants.CATEGORY
+sre_constants.CATEGORY_DIGIT
+sre_constants.CATEGORY_LINEBREAK
+sre_constants.CATEGORY_LOC_NOT_WORD
+sre_constants.CATEGORY_LOC_WORD
+sre_constants.CATEGORY_NOT_DIGIT
+sre_constants.CATEGORY_NOT_LINEBREAK
+sre_constants.CATEGORY_NOT_SPACE
+sre_constants.CATEGORY_NOT_WORD
+sre_constants.CATEGORY_SPACE
+sre_constants.CATEGORY_UNI_DIGIT
+sre_constants.CATEGORY_UNI_LINEBREAK
+sre_constants.CATEGORY_UNI_NOT_DIGIT
+sre_constants.CATEGORY_UNI_NOT_LINEBREAK
+sre_constants.CATEGORY_UNI_NOT_SPACE
+sre_constants.CATEGORY_UNI_NOT_WORD
+sre_constants.CATEGORY_UNI_SPACE
+sre_constants.CATEGORY_UNI_WORD
+sre_constants.CATEGORY_WORD
+sre_constants.CHARSET
+sre_constants.CHCODES
+sre_constants.CH_LOCALE
+sre_constants.CH_UNICODE
+sre_constants.FAILURE
+sre_constants.GROUPREF
+sre_constants.GROUPREF_EXISTS
+sre_constants.GROUPREF_IGNORE
+sre_constants.IN
+sre_constants.INFO
+sre_constants.IN_IGNORE
+sre_constants.JUMP
+sre_constants.LITERAL
+sre_constants.LITERAL_IGNORE
+sre_constants.MAGIC
+sre_constants.MARK
+sre_constants.MAXREPEAT
+sre_constants.MAX_REPEAT
+sre_constants.MAX_UNTIL
+sre_constants.MIN_REPEAT
+sre_constants.MIN_REPEAT_ONE
+sre_constants.MIN_UNTIL
+sre_constants.NEGATE
+sre_constants.NOT_LITERAL
+sre_constants.NOT_LITERAL_IGNORE
+sre_constants.OPCODES
+sre_constants.OP_IGNORE
+sre_constants.RANGE
+sre_constants.REPEAT
+sre_constants.REPEAT_ONE
+sre_constants.SRE_FLAG_DEBUG
+sre_constants.SRE_FLAG_DOTALL
+sre_constants.SRE_FLAG_IGNORECASE
+sre_constants.SRE_FLAG_LOCALE
+sre_constants.SRE_FLAG_MULTILINE
+sre_constants.SRE_FLAG_TEMPLATE
+sre_constants.SRE_FLAG_UNICODE
+sre_constants.SRE_FLAG_VERBOSE
+sre_constants.SRE_INFO_CHARSET
+sre_constants.SRE_INFO_LITERAL
+sre_constants.SRE_INFO_PREFIX
+sre_constants.SUBPATTERN
+sre_constants.SUCCESS
+sre_constants.error(??)
+sre_constants.makedict(??)
+sre_parse.ANY
+sre_parse.ANY_ALL
+sre_parse.ASSERT
+sre_parse.ASSERT_NOT
+sre_parse.AT
+sre_parse.ATCODES
+sre_parse.AT_BEGINNING
+sre_parse.AT_BEGINNING_LINE
+sre_parse.AT_BEGINNING_STRING
+sre_parse.AT_BOUNDARY
+sre_parse.AT_END
+sre_parse.AT_END_LINE
+sre_parse.AT_END_STRING
+sre_parse.AT_LOCALE
+sre_parse.AT_LOC_BOUNDARY
+sre_parse.AT_LOC_NON_BOUNDARY
+sre_parse.AT_MULTILINE
+sre_parse.AT_NON_BOUNDARY
+sre_parse.AT_UNICODE
+sre_parse.AT_UNI_BOUNDARY
+sre_parse.AT_UNI_NON_BOUNDARY
+sre_parse.BIGCHARSET
+sre_parse.BRANCH
+sre_parse.CALL
+sre_parse.CATEGORIES
+sre_parse.CATEGORY
+sre_parse.CATEGORY_DIGIT
+sre_parse.CATEGORY_LINEBREAK
+sre_parse.CATEGORY_LOC_NOT_WORD
+sre_parse.CATEGORY_LOC_WORD
+sre_parse.CATEGORY_NOT_DIGIT
+sre_parse.CATEGORY_NOT_LINEBREAK
+sre_parse.CATEGORY_NOT_SPACE
+sre_parse.CATEGORY_NOT_WORD
+sre_parse.CATEGORY_SPACE
+sre_parse.CATEGORY_UNI_DIGIT
+sre_parse.CATEGORY_UNI_LINEBREAK
+sre_parse.CATEGORY_UNI_NOT_DIGIT
+sre_parse.CATEGORY_UNI_NOT_LINEBREAK
+sre_parse.CATEGORY_UNI_NOT_SPACE
+sre_parse.CATEGORY_UNI_NOT_WORD
+sre_parse.CATEGORY_UNI_SPACE
+sre_parse.CATEGORY_UNI_WORD
+sre_parse.CATEGORY_WORD
+sre_parse.CHARSET
+sre_parse.CHCODES
+sre_parse.CH_LOCALE
+sre_parse.CH_UNICODE
+sre_parse.DIGITS
+sre_parse.ESCAPES
+sre_parse.FAILURE
+sre_parse.FLAGS
+sre_parse.GROUPREF
+sre_parse.GROUPREF_EXISTS
+sre_parse.GROUPREF_IGNORE
+sre_parse.HEXDIGITS
+sre_parse.IN
+sre_parse.INFO
+sre_parse.IN_IGNORE
+sre_parse.JUMP
+sre_parse.LITERAL
+sre_parse.LITERAL_IGNORE
+sre_parse.MAGIC
+sre_parse.MARK
+sre_parse.MAXREPEAT
+sre_parse.MAX_REPEAT
+sre_parse.MAX_UNTIL
+sre_parse.MIN_REPEAT
+sre_parse.MIN_REPEAT_ONE
+sre_parse.MIN_UNTIL
+sre_parse.NEGATE
+sre_parse.NOT_LITERAL
+sre_parse.NOT_LITERAL_IGNORE
+sre_parse.OCTDIGITS
+sre_parse.OPCODES
+sre_parse.OP_IGNORE
+sre_parse.Pattern(??)
+sre_parse.RANGE
+sre_parse.REPEAT
+sre_parse.REPEAT_CHARS
+sre_parse.REPEAT_ONE
+sre_parse.SPECIAL_CHARS
+sre_parse.SRE_FLAG_DEBUG
+sre_parse.SRE_FLAG_DOTALL
+sre_parse.SRE_FLAG_IGNORECASE
+sre_parse.SRE_FLAG_LOCALE
+sre_parse.SRE_FLAG_MULTILINE
+sre_parse.SRE_FLAG_TEMPLATE
+sre_parse.SRE_FLAG_UNICODE
+sre_parse.SRE_FLAG_VERBOSE
+sre_parse.SRE_INFO_CHARSET
+sre_parse.SRE_INFO_LITERAL
+sre_parse.SRE_INFO_PREFIX
+sre_parse.SUBPATTERN
+sre_parse.SUCCESS
+sre_parse.SubPattern(??)
+sre_parse.Tokenizer(??)
+sre_parse.WHITESPACE
+sre_parse.error(??)
+sre_parse.expand_template(??)
+sre_parse.isdigit(??)
+sre_parse.isident(??)
+sre_parse.isname(??)
+sre_parse.makedict(??)
+sre_parse.parse(??)
+sre_parse.parse_template(??)
+sre_parse.sys
+stat.ST_ATIME
+stat.ST_CTIME
+stat.ST_DEV
+stat.ST_GID
+stat.ST_INO
+stat.ST_MODE
+stat.ST_MTIME
+stat.ST_NLINK
+stat.ST_SIZE
+stat.ST_UID
+stat.S_ENFMT
+stat.S_IEXEC
+stat.S_IFBLK
+stat.S_IFCHR
+stat.S_IFDIR
+stat.S_IFIFO
+stat.S_IFLNK
+stat.S_IFMT(??)
+stat.S_IFREG
+stat.S_IFSOCK
+stat.S_IMODE(??)
+stat.S_IREAD
+stat.S_IRGRP
+stat.S_IROTH
+stat.S_IRUSR
+stat.S_IRWXG
+stat.S_IRWXO
+stat.S_IRWXU
+stat.S_ISBLK(??)
+stat.S_ISCHR(??)
+stat.S_ISDIR(??)
+stat.S_ISFIFO(??)
+stat.S_ISGID
+stat.S_ISLNK(??)
+stat.S_ISREG(??)
+stat.S_ISSOCK(??)
+stat.S_ISUID
+stat.S_ISVTX
+stat.S_IWGRP
+stat.S_IWOTH
+stat.S_IWRITE
+stat.S_IWUSR
+stat.S_IXGRP
+stat.S_IXOTH
+stat.S_IXUSR
+statcache.ST_ATIME
+statcache.ST_CTIME
+statcache.ST_DEV
+statcache.ST_GID
+statcache.ST_INO
+statcache.ST_MODE
+statcache.ST_MTIME
+statcache.ST_NLINK
+statcache.ST_SIZE
+statcache.ST_UID
+statcache.S_ENFMT
+statcache.S_IEXEC
+statcache.S_IFBLK
+statcache.S_IFCHR
+statcache.S_IFDIR
+statcache.S_IFIFO
+statcache.S_IFLNK
+statcache.S_IFMT(??)
+statcache.S_IFREG
+statcache.S_IFSOCK
+statcache.S_IMODE(??)
+statcache.S_IREAD
+statcache.S_IRGRP
+statcache.S_IROTH
+statcache.S_IRUSR
+statcache.S_IRWXG
+statcache.S_IRWXO
+statcache.S_IRWXU
+statcache.S_ISBLK(??)
+statcache.S_ISCHR(??)
+statcache.S_ISDIR(??)
+statcache.S_ISFIFO(??)
+statcache.S_ISGID
+statcache.S_ISLNK(??)
+statcache.S_ISREG(??)
+statcache.S_ISSOCK(??)
+statcache.S_ISUID
+statcache.S_ISVTX
+statcache.S_IWGRP
+statcache.S_IWOTH
+statcache.S_IWRITE
+statcache.S_IWUSR
+statcache.S_IXGRP
+statcache.S_IXOTH
+statcache.S_IXUSR
+statcache.cache
+statcache.forget(??)
+statcache.forget_dir(??)
+statcache.forget_except_prefix(??)
+statcache.forget_prefix(??)
+statcache.isdir(??)
+statcache.reset(??)
+statcache.stat(??)
+staticmethod(function) -> method
+statvfs.F_BAVAIL
+statvfs.F_BFREE
+statvfs.F_BLOCKS
+statvfs.F_BSIZE
+statvfs.F_FAVAIL
+statvfs.F_FFREE
+statvfs.F_FILES
+statvfs.F_FLAG
+statvfs.F_FRSIZE
+statvfs.F_NAMEMAX
+str(object) -> string
+string.Template
+string.ascii_letters
+string.ascii_lowercase
+string.ascii_uppercase
+string.atof(s) -> float
+string.atof_error(??)
+string.atoi(s [,base]) -> int
+string.atoi_error(??)
+string.atol(s [,base]) -> long
+string.atol_error(??)
+string.capitalize(s) -> string
+string.capwords(s, [sep]) -> string
+string.center(s, width[, fillchar]) -> string
+string.count(s, sub[, start[,end]]) -> int
+string.digits
+string.expandtabs(s [,tabsize]) -> string
+string.find(s, sub [,start [,end]]) -> in
+string.hexdigits
+string.index(s, sub [,start [,end]]) -> int
+string.index_error(??)
+string.join(list [,sep]) -> string
+string.joinfields(??)
+string.letters
+string.ljust(s, width[, fillchar]) -> string
+string.lower(s) -> string
+string.lowercase
+string.lstrip(s [,chars]) -> string
+string.maketrans(frm, to) -> string
+string.octdigits
+string.printable
+string.punctuation
+string.replace (str, old, new[, maxsplit]) -> string
+string.rfind(s, sub [,start [,end]]) -> int
+string.rindex(s, sub [,start [,end]]) -> int
+string.rjust(s, width[, fillchar]) -> string
+string.rsplit(s [,sep [,maxsplit]]) -> list of strings
+string.rstrip(s [,chars]) -> string
+string.split(s [,sep [,maxsplit]]) -> list of strings
+string.splitfields(??)
+string.strip(s [,chars]) -> string
+string.swapcase(s) -> string
+string.translate(s,table [,deletions]) -> string
+string.upper(s) -> string
+string.uppercase
+string.whitespace
+string.zfill(x, width) -> string
+stringold.atof(s) -> float
+stringold.atof_error(??)
+stringold.atoi(s [,base]) -> int
+stringold.atoi_error(??)
+stringold.atol(s [,base]) -> long
+stringold.atol_error(??)
+stringold.capitalize(s) -> string
+stringold.capwords(s, [sep]) -> string
+stringold.center(s, width) -> string
+stringold.count(s, sub[, start[,end]]) -> int
+stringold.digits
+stringold.expandtabs(s [,tabsize]) -> string
+stringold.find(s, sub [,start [,end]]) -> in
+stringold.hexdigits
+stringold.index(s, sub [,start [,end]]) -> int
+stringold.index_error(??)
+stringold.join(list [,sep]) -> string
+stringold.joinfields(??)
+stringold.letters
+stringold.ljust(s, width) -> string
+stringold.lower(s) -> string
+stringold.lowercase
+stringold.lstrip(s) -> string
+stringold.maketrans(frm, to) -> string
+stringold.octdigits
+stringold.replace (str, old, new[, maxsplit]) -> string
+stringold.rfind(s, sub [,start [,end]]) -> int
+stringold.rindex(s, sub [,start [,end]]) -> int
+stringold.rjust(s, width) -> string
+stringold.rstrip(s) -> string
+stringold.split(str [,sep [,maxsplit]]) -> list of strings
+stringold.splitfields(??)
+stringold.strip(s) -> string
+stringold.swapcase(s) -> string
+stringold.translate(s,table [,deletechars]) -> string
+stringold.upper(s) -> string
+stringold.uppercase
+stringold.whitespace
+stringold.zfill(x, width) -> string
+stringprep.b1_set
+stringprep.b3_exceptions
+stringprep.c22_specials
+stringprep.c6_set
+stringprep.c7_set
+stringprep.c8_set
+stringprep.c9_set
+stringprep.in_table_a1(??)
+stringprep.in_table_b1(??)
+stringprep.in_table_c11(??)
+stringprep.in_table_c11_c12(??)
+stringprep.in_table_c12(??)
+stringprep.in_table_c21(??)
+stringprep.in_table_c21_c22(??)
+stringprep.in_table_c22(??)
+stringprep.in_table_c3(??)
+stringprep.in_table_c4(??)
+stringprep.in_table_c5(??)
+stringprep.in_table_c6(??)
+stringprep.in_table_c7(??)
+stringprep.in_table_c8(??)
+stringprep.in_table_c9(??)
+stringprep.in_table_d1(??)
+stringprep.in_table_d2(??)
+stringprep.map_table_b2(??)
+stringprep.map_table_b3(??)
+stringprep.unicodedata
+strop.atof(s) -> float
+strop.atoi(s [,base]) -> int
+strop.atol(s [,base]) -> long
+strop.capitalize(s) -> string
+strop.count(s, sub[, start[, end]]) -> int
+strop.expandtabs(string, [tabsize]) -> string
+strop.find(s, sub [,start [,end]]) -> in
+strop.join(list [,sep]) -> string
+strop.joinfields
+strop.lower(s) -> string
+strop.lowercase
+strop.lstrip(s) -> string
+strop.maketrans(frm, to) -> string
+strop.replace (str, old, new[, maxsplit]) -> string
+strop.rfind(s, sub [,start [,end]]) -> int
+strop.rstrip(s) -> string
+strop.split(s [,sep [,maxsplit]]) -> list of strings
+strop.splitfields
+strop.strip(s) -> string
+strop.swapcase(s) -> string
+strop.translate(s,table [,deletechars]) -> string
+strop.upper(s) -> string
+strop.uppercase
+strop.whitespace
+struct.calcsize(fmt) -> int
+struct.error(??)
+struct.pack(fmt, v1, v2, ...) -> string
+struct.unpack(fmt, string) -> (v1, v2, ...)
+subprocess.MAXFD
+subprocess.PIPE
+subprocess.Popen
+subprocess.STDOUT
+subprocess.call(??)
+subprocess.errno
+subprocess.fcntl
+subprocess.list2cmdline(??)
+subprocess.mswindows
+subprocess.os
+subprocess.pickle
+subprocess.select
+subprocess.sys
+subprocess.traceback
+subprocess.types
+sum(sequence, start=0) -> value
+sunau.AUDIO_FILE_ENCODING_ADPCM_G721
+sunau.AUDIO_FILE_ENCODING_ADPCM_G722
+sunau.AUDIO_FILE_ENCODING_ADPCM_G723_3
+sunau.AUDIO_FILE_ENCODING_ADPCM_G723_5
+sunau.AUDIO_FILE_ENCODING_ALAW_8
+sunau.AUDIO_FILE_ENCODING_DOUBLE
+sunau.AUDIO_FILE_ENCODING_FLOAT
+sunau.AUDIO_FILE_ENCODING_LINEAR_16
+sunau.AUDIO_FILE_ENCODING_LINEAR_24
+sunau.AUDIO_FILE_ENCODING_LINEAR_32
+sunau.AUDIO_FILE_ENCODING_LINEAR_8
+sunau.AUDIO_FILE_ENCODING_MULAW_8
+sunau.AUDIO_FILE_MAGIC
+sunau.AUDIO_UNKNOWN_SIZE
+sunau.Au_read(??)
+sunau.Au_write(??)
+sunau.Error(??)
+sunau.open(??)
+sunau.openfp(??)
+sunaudio.MAGIC
+sunaudio.error(??)
+sunaudio.get_long_be(??)
+sunaudio.gethdr(??)
+sunaudio.printhdr(??)
+super(type) -> unbound super object
+symbol.and_expr
+symbol.and_test
+symbol.arglist
+symbol.argument
+symbol.arith_expr
+symbol.assert_stmt
+symbol.atom
+symbol.augassign
+symbol.break_stmt
+symbol.classdef
+symbol.comp_op
+symbol.comparison
+symbol.compound_stmt
+symbol.continue_stmt
+symbol.decorator
+symbol.decorators
+symbol.del_stmt
+symbol.dictmaker
+symbol.dotted_as_name
+symbol.dotted_as_names
+symbol.dotted_name
+symbol.encoding_decl
+symbol.eval_input
+symbol.except_clause
+symbol.exec_stmt
+symbol.expr
+symbol.expr_stmt
+symbol.exprlist
+symbol.factor
+symbol.file_input
+symbol.flow_stmt
+symbol.for_stmt
+symbol.fpdef
+symbol.fplist
+symbol.funcdef
+symbol.gen_for
+symbol.gen_if
+symbol.gen_iter
+symbol.global_stmt
+symbol.if_stmt
+symbol.import_as_name
+symbol.import_as_names
+symbol.import_from
+symbol.import_name
+symbol.import_stmt
+symbol.lambdef
+symbol.list_for
+symbol.list_if
+symbol.list_iter
+symbol.listmaker
+symbol.main(??)
+symbol.not_test
+symbol.parameters
+symbol.pass_stmt
+symbol.power
+symbol.print_stmt
+symbol.raise_stmt
+symbol.return_stmt
+symbol.shift_expr
+symbol.simple_stmt
+symbol.single_input
+symbol.sliceop
+symbol.small_stmt
+symbol.stmt
+symbol.subscript
+symbol.subscriptlist
+symbol.suite
+symbol.sym_name
+symbol.term
+symbol.test
+symbol.testlist
+symbol.testlist1
+symbol.testlist_gexp
+symbol.testlist_safe
+symbol.trailer
+symbol.try_stmt
+symbol.varargslist
+symbol.while_stmt
+symbol.xor_expr
+symbol.yield_stmt
+symtable.Class(??)
+symtable.DEF_BOUND
+symtable.DEF_DOUBLESTAR
+symtable.DEF_FREE
+symtable.DEF_FREE_CLASS
+symtable.DEF_FREE_GLOBAL
+symtable.DEF_GLOBAL
+symtable.DEF_IMPORT
+symtable.DEF_INTUPLE
+symtable.DEF_LOCAL
+symtable.DEF_PARAM
+symtable.DEF_STAR
+symtable.Function(??)
+symtable.OPT_BARE_EXEC
+symtable.OPT_EXEC
+symtable.OPT_IMPORT_STAR
+symtable.Symbol(??)
+symtable.SymbolTable(??)
+symtable.SymbolTableFactory(??)
+symtable.USE
+symtable.is_free(??)
+symtable.newSymbolTable
+symtable.symtable(??)
+symtable.weakref
+sys.api_version
+sys.argv
+sys.builtin_module_names
+sys.byteorder
+sys.call_tracing(func, args) -> object
+sys.callstats() -> tuple of integers
+sys.copyright
+sys.displayhook(object) -> None
+sys.exc_clear() -> None
+sys.exc_info() -> (type, value, traceback)
+sys.exc_type
+sys.excepthook(exctype, value, traceback) -> None
+sys.exec_prefix
+sys.executable
+sys.exit([status])
+sys.getcheckinterval() -> current check interval; see setcheckinterval().
+sys.getdefaultencoding() -> string
+sys.getdlopenflags() -> int
+sys.getfilesystemencoding() -> string
+sys.getrecursionlimit()
+sys.getrefcount(object) -> integer
+sys.hexversion
+sys.maxint
+sys.maxunicode
+sys.meta_path
+sys.modules
+sys.path
+sys.path_hooks
+sys.path_importer_cache
+sys.platform
+sys.prefix
+sys.setcheckinterval(n)
+sys.setdlopenflags(n) -> None
+sys.setprofile(function)
+sys.setrecursionlimit(n)
+sys.settrace(function)
+sys.stderr
+sys.stdin
+sys.stdout
+sys.version
+sys.version_info
+sys.warnoptions
+syslog.LOG_ALERT
+syslog.LOG_AUTH
+syslog.LOG_CONS
+syslog.LOG_CRIT
+syslog.LOG_CRON
+syslog.LOG_DAEMON
+syslog.LOG_DEBUG
+syslog.LOG_EMERG
+syslog.LOG_ERR
+syslog.LOG_INFO
+syslog.LOG_KERN
+syslog.LOG_LOCAL0
+syslog.LOG_LOCAL1
+syslog.LOG_LOCAL2
+syslog.LOG_LOCAL3
+syslog.LOG_LOCAL4
+syslog.LOG_LOCAL5
+syslog.LOG_LOCAL6
+syslog.LOG_LOCAL7
+syslog.LOG_LPR
+syslog.LOG_MAIL
+syslog.LOG_MASK
+syslog.LOG_NDELAY
+syslog.LOG_NEWS
+syslog.LOG_NOTICE
+syslog.LOG_NOWAIT
+syslog.LOG_PERROR
+syslog.LOG_PID
+syslog.LOG_SYSLOG
+syslog.LOG_UPTO
+syslog.LOG_USER
+syslog.LOG_UUCP
+syslog.LOG_WARNING
+syslog.closelog
+syslog.openlog
+syslog.setlogmask
+syslog.syslog
+tabnanny.NannyNag(??)
+tabnanny.Whitespace(??)
+tabnanny.check(file_or_dir)
+tabnanny.errprint(??)
+tabnanny.filename_only
+tabnanny.format_witnesses(??)
+tabnanny.getopt
+tabnanny.main(??)
+tabnanny.os
+tabnanny.process_tokens(??)
+tabnanny.sys
+tabnanny.tokenize
+tabnanny.verbose
+tarfile.AREGTYPE
+tarfile.BLKTYPE
+tarfile.BLOCKSIZE
+tarfile.CHRTYPE
+tarfile.CONTTYPE
+tarfile.CompressionError(??)
+tarfile.DIRTYPE
+tarfile.ExFileObject
+tarfile.ExtractError(??)
+tarfile.FIFOTYPE
+tarfile.GNUTYPE_LONGLINK
+tarfile.GNUTYPE_LONGNAME
+tarfile.GNUTYPE_SPARSE
+tarfile.LENGTH_LINK
+tarfile.LENGTH_NAME
+tarfile.LENGTH_PREFIX
+tarfile.LNKTYPE
+tarfile.MAGIC
+tarfile.MAXSIZE_MEMBER
+tarfile.NUL
+tarfile.RECORDSIZE
+tarfile.REGTYPE
+tarfile.REGULAR_TYPES
+tarfile.ReadError(??)
+tarfile.SUPPORTED_TYPES
+tarfile.SYMTYPE
+tarfile.S_IFBLK
+tarfile.S_IFCHR
+tarfile.S_IFDIR
+tarfile.S_IFIFO
+tarfile.S_IFLNK
+tarfile.S_IFREG
+tarfile.StreamError(??)
+tarfile.TAR_GZIPPED
+tarfile.TAR_PLAIN
+tarfile.TGEXEC
+tarfile.TGREAD
+tarfile.TGWRITE
+tarfile.TOEXEC
+tarfile.TOREAD
+tarfile.TOWRITE
+tarfile.TSGID
+tarfile.TSUID
+tarfile.TSVTX
+tarfile.TUEXEC
+tarfile.TUREAD
+tarfile.TUWRITE
+tarfile.TarError(??)
+tarfile.TarFile
+tarfile.TarFileCompat(??)
+tarfile.TarInfo
+tarfile.TarIter(??)
+tarfile.VERSION
+tarfile.calc_chksum(??)
+tarfile.copyfileobj(??)
+tarfile.errno
+tarfile.filemode(??)
+tarfile.filemode_table
+tarfile.grp
+tarfile.is_tarfile(??)
+tarfile.normpath(??)
+tarfile.nts(??)
+tarfile.open
+tarfile.os
+tarfile.pwd
+tarfile.shutil
+tarfile.stat
+tarfile.struct
+tarfile.sys
+tarfile.time
+tarfile.version
+telnetlib.AO
+telnetlib.AUTHENTICATION
+telnetlib.AYT
+telnetlib.BINARY
+telnetlib.BM
+telnetlib.BRK
+telnetlib.CHARSET
+telnetlib.COM_PORT_OPTION
+telnetlib.DEBUGLEVEL
+telnetlib.DET
+telnetlib.DM
+telnetlib.DO
+telnetlib.DONT
+telnetlib.EC
+telnetlib.ECHO
+telnetlib.EL
+telnetlib.ENCRYPT
+telnetlib.EOR
+telnetlib.EXOPL
+telnetlib.FORWARD_X
+telnetlib.GA
+telnetlib.IAC
+telnetlib.IP
+telnetlib.KERMIT
+telnetlib.LFLOW
+telnetlib.LINEMODE
+telnetlib.LOGOUT
+telnetlib.NAMS
+telnetlib.NAOCRD
+telnetlib.NAOFFD
+telnetlib.NAOHTD
+telnetlib.NAOHTS
+telnetlib.NAOL
+telnetlib.NAOLFD
+telnetlib.NAOP
+telnetlib.NAOVTD
+telnetlib.NAOVTS
+telnetlib.NAWS
+telnetlib.NEW_ENVIRON
+telnetlib.NOOPT
+telnetlib.NOP
+telnetlib.OLD_ENVIRON
+telnetlib.OUTMRK
+telnetlib.PRAGMA_HEARTBEAT
+telnetlib.PRAGMA_LOGON
+telnetlib.RCP
+telnetlib.RCTE
+telnetlib.RSP
+telnetlib.SB
+telnetlib.SE
+telnetlib.SEND_URL
+telnetlib.SGA
+telnetlib.SNDLOC
+telnetlib.SSPI_LOGON
+telnetlib.STATUS
+telnetlib.SUPDUP
+telnetlib.SUPDUPOUTPUT
+telnetlib.SUPPRESS_LOCAL_ECHO
+telnetlib.TELNET_PORT
+telnetlib.TLS
+telnetlib.TM
+telnetlib.TN3270E
+telnetlib.TSPEED
+telnetlib.TTYLOC
+telnetlib.TTYPE
+telnetlib.TUID
+telnetlib.Telnet(??)
+telnetlib.VT3270REGIME
+telnetlib.WILL
+telnetlib.WONT
+telnetlib.X3PAD
+telnetlib.XASCII
+telnetlib.XAUTH
+telnetlib.XDISPLOC
+telnetlib.select
+telnetlib.socket
+telnetlib.sys
+telnetlib.test(??)
+telnetlib.theNULL
+tempfile.NamedTemporaryFile(??)
+tempfile.TMP_MAX
+tempfile.TemporaryFile(??)
+tempfile.gettempdir(??)
+tempfile.gettempprefix(??)
+tempfile.mkdtemp([suffix, [prefix, [dir]]])
+tempfile.mkstemp([suffix, [prefix, [dir, [text]]]])
+tempfile.mktemp([suffix, [prefix, [dir]]])
+tempfile.tempdir
+tempfile.template
+termios.B0
+termios.B110
+termios.B115200
+termios.B1200
+termios.B134
+termios.B150
+termios.B1800
+termios.B19200
+termios.B200
+termios.B230400
+termios.B2400
+termios.B300
+termios.B38400
+termios.B460800
+termios.B4800
+termios.B50
+termios.B57600
+termios.B600
+termios.B75
+termios.B9600
+termios.BRKINT
+termios.BS0
+termios.BS1
+termios.BSDLY
+termios.CBAUD
+termios.CBAUDEX
+termios.CDSUSP
+termios.CEOF
+termios.CEOL
+termios.CEOT
+termios.CERASE
+termios.CFLUSH
+termios.CIBAUD
+termios.CINTR
+termios.CKILL
+termios.CLNEXT
+termios.CLOCAL
+termios.CQUIT
+termios.CR0
+termios.CR1
+termios.CR2
+termios.CR3
+termios.CRDLY
+termios.CREAD
+termios.CRPRNT
+termios.CRTSCTS
+termios.CS5
+termios.CS6
+termios.CS7
+termios.CS8
+termios.CSIZE
+termios.CSTART
+termios.CSTOP
+termios.CSTOPB
+termios.CSUSP
+termios.CWERASE
+termios.ECHO
+termios.ECHOCTL
+termios.ECHOE
+termios.ECHOK
+termios.ECHOKE
+termios.ECHONL
+termios.ECHOPRT
+termios.EXTA
+termios.EXTB
+termios.FF0
+termios.FF1
+termios.FFDLY
+termios.FIOASYNC
+termios.FIOCLEX
+termios.FIONBIO
+termios.FIONCLEX
+termios.FIONREAD
+termios.FLUSHO
+termios.HUPCL
+termios.ICANON
+termios.ICRNL
+termios.IEXTEN
+termios.IGNBRK
+termios.IGNCR
+termios.IGNPAR
+termios.IMAXBEL
+termios.INLCR
+termios.INPCK
+termios.IOCSIZE_MASK
+termios.IOCSIZE_SHIFT
+termios.ISIG
+termios.ISTRIP
+termios.IUCLC
+termios.IXANY
+termios.IXOFF
+termios.IXON
+termios.NCC
+termios.NCCS
+termios.NL0
+termios.NL1
+termios.NLDLY
+termios.NOFLSH
+termios.N_MOUSE
+termios.N_PPP
+termios.N_SLIP
+termios.N_STRIP
+termios.N_TTY
+termios.OCRNL
+termios.OFDEL
+termios.OFILL
+termios.OLCUC
+termios.ONLCR
+termios.ONLRET
+termios.ONOCR
+termios.OPOST
+termios.PARENB
+termios.PARMRK
+termios.PARODD
+termios.PENDIN
+termios.TAB0
+termios.TAB1
+termios.TAB2
+termios.TAB3
+termios.TABDLY
+termios.TCFLSH
+termios.TCGETA
+termios.TCGETS
+termios.TCIFLUSH
+termios.TCIOFF
+termios.TCIOFLUSH
+termios.TCION
+termios.TCOFLUSH
+termios.TCOOFF
+termios.TCOON
+termios.TCSADRAIN
+termios.TCSAFLUSH
+termios.TCSANOW
+termios.TCSBRK
+termios.TCSBRKP
+termios.TCSETA
+termios.TCSETAF
+termios.TCSETAW
+termios.TCSETS
+termios.TCSETSF
+termios.TCSETSW
+termios.TCXONC
+termios.TIOCCONS
+termios.TIOCEXCL
+termios.TIOCGETD
+termios.TIOCGICOUNT
+termios.TIOCGLCKTRMIOS
+termios.TIOCGPGRP
+termios.TIOCGSERIAL
+termios.TIOCGSOFTCAR
+termios.TIOCGWINSZ
+termios.TIOCINQ
+termios.TIOCLINUX
+termios.TIOCMBIC
+termios.TIOCMBIS
+termios.TIOCMGET
+termios.TIOCMIWAIT
+termios.TIOCMSET
+termios.TIOCM_CAR
+termios.TIOCM_CD
+termios.TIOCM_CTS
+termios.TIOCM_DSR
+termios.TIOCM_DTR
+termios.TIOCM_LE
+termios.TIOCM_RI
+termios.TIOCM_RNG
+termios.TIOCM_RTS
+termios.TIOCM_SR
+termios.TIOCM_ST
+termios.TIOCNOTTY
+termios.TIOCNXCL
+termios.TIOCOUTQ
+termios.TIOCPKT
+termios.TIOCPKT_DATA
+termios.TIOCPKT_DOSTOP
+termios.TIOCPKT_FLUSHREAD
+termios.TIOCPKT_FLUSHWRITE
+termios.TIOCPKT_NOSTOP
+termios.TIOCPKT_START
+termios.TIOCPKT_STOP
+termios.TIOCSCTTY
+termios.TIOCSERCONFIG
+termios.TIOCSERGETLSR
+termios.TIOCSERGETMULTI
+termios.TIOCSERGSTRUCT
+termios.TIOCSERGWILD
+termios.TIOCSERSETMULTI
+termios.TIOCSERSWILD
+termios.TIOCSER_TEMT
+termios.TIOCSETD
+termios.TIOCSLCKTRMIOS
+termios.TIOCSPGRP
+termios.TIOCSSERIAL
+termios.TIOCSSOFTCAR
+termios.TIOCSTI
+termios.TIOCSWINSZ
+termios.TOSTOP
+termios.VDISCARD
+termios.VEOF
+termios.VEOL
+termios.VEOL2
+termios.VERASE
+termios.VINTR
+termios.VKILL
+termios.VLNEXT
+termios.VMIN
+termios.VQUIT
+termios.VREPRINT
+termios.VSTART
+termios.VSTOP
+termios.VSUSP
+termios.VSWTC
+termios.VSWTCH
+termios.VT0
+termios.VT1
+termios.VTDLY
+termios.VTIME
+termios.VWERASE
+termios.XCASE
+termios.XTABS
+termios.error(??)
+termios.tcdrain(fd) -> None
+termios.tcflow(fd, action) -> None
+termios.tcflush(fd, queue) -> None
+termios.tcgetattr(fd) -> list_of_attrs
+termios.tcsendbreak(fd, duration) -> None
+termios.tcsetattr(fd, when, attributes) -> None
+textwrap.TextWrapper(??)
+textwrap.dedent(text : string) -> string
+textwrap.fill(??)
+textwrap.re
+textwrap.string
+textwrap.wrap(??)
+this.c
+this.d
+this.i
+this.s
+thread.LockType
+thread.allocate
+thread.allocate_lock() -> lock object
+thread.error(??)
+thread.exit()
+thread.exit_thread
+thread.get_ident() -> integer
+thread.interrupt_main()
+thread.start_new
+thread.start_new_thread(function, args[, kwargs])
+threading.BoundedSemaphore(??)
+threading.Condition(??)
+threading.Event(??)
+threading.Lock
+threading.RLock(??)
+threading.Semaphore(??)
+threading.Thread
+threading.ThreadError(??)
+threading.Timer(??)
+threading.activeCount(??)
+threading.currentThread(??)
+threading.deque(iterable) --> deque object
+threading.enumerate(??)
+threading.local
+threading.setprofile(??)
+threading.settrace(??)
+time.accept2dyear
+time.altzone
+time.asctime([tuple]) -> string
+time.clock() -> floating point number
+time.ctime(seconds) -> string
+time.daylight
+time.gmtime([seconds]) -> (tm_year, tm_mon, tm_day, tm_hour, tm_min,
+time.localtime([seconds]) -> (tm_year,tm_mon,tm_day,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
+time.mktime(tuple) -> floating point number
+time.sleep(seconds)
+time.strftime(format[, tuple]) -> string
+time.strptime(string, format) -> struct_time
+time.struct_time
+time.time() -> floating point number
+time.timezone
+time.tzname
+time.tzset(zone)
+timeit.Timer(??)
+timeit.default_number
+timeit.default_repeat
+timeit.default_timer
+timeit.dummy_src_name
+timeit.gc
+timeit.itertools
+timeit.main(??)
+timeit.reindent(??)
+timeit.sys
+timeit.template
+timeit.time
+timing.finish
+timing.micro
+timing.milli
+timing.seconds
+timing.start
+toaiff.error(??)
+toaiff.os
+toaiff.pipes
+toaiff.sndhdr
+toaiff.t
+toaiff.table
+toaiff.tempfile
+toaiff.toaiff(??)
+toaiff.uncompress
+token.AMPER
+token.AMPEREQUAL
+token.AT
+token.BACKQUOTE
+token.CIRCUMFLEX
+token.CIRCUMFLEXEQUAL
+token.COLON
+token.COMMA
+token.DEDENT
+token.DOT
+token.DOUBLESLASH
+token.DOUBLESLASHEQUAL
+token.DOUBLESTAR
+token.DOUBLESTAREQUAL
+token.ENDMARKER
+token.EQEQUAL
+token.EQUAL
+token.ERRORTOKEN
+token.GREATER
+token.GREATEREQUAL
+token.INDENT
+token.ISEOF(??)
+token.ISNONTERMINAL(??)
+token.ISTERMINAL(??)
+token.LBRACE
+token.LEFTSHIFT
+token.LEFTSHIFTEQUAL
+token.LESS
+token.LESSEQUAL
+token.LPAR
+token.LSQB
+token.MINEQUAL
+token.MINUS
+token.NAME
+token.NEWLINE
+token.NOTEQUAL
+token.NT_OFFSET
+token.NUMBER
+token.N_TOKENS
+token.OP
+token.PERCENT
+token.PERCENTEQUAL
+token.PLUS
+token.PLUSEQUAL
+token.RBRACE
+token.RIGHTSHIFT
+token.RIGHTSHIFTEQUAL
+token.RPAR
+token.RSQB
+token.SEMI
+token.SLASH
+token.SLASHEQUAL
+token.STAR
+token.STAREQUAL
+token.STRING
+token.TILDE
+token.VBAR
+token.VBAREQUAL
+token.main(??)
+token.tok_name
+tokenize.AMPER
+tokenize.AMPEREQUAL
+tokenize.AT
+tokenize.BACKQUOTE
+tokenize.Bracket
+tokenize.CIRCUMFLEX
+tokenize.CIRCUMFLEXEQUAL
+tokenize.COLON
+tokenize.COMMA
+tokenize.COMMENT
+tokenize.Comment
+tokenize.ContStr
+tokenize.DEDENT
+tokenize.DOT
+tokenize.DOUBLESLASH
+tokenize.DOUBLESLASHEQUAL
+tokenize.DOUBLESTAR
+tokenize.DOUBLESTAREQUAL
+tokenize.Decnumber
+tokenize.Double
+tokenize.Double3
+tokenize.ENDMARKER
+tokenize.EQEQUAL
+tokenize.EQUAL
+tokenize.ERRORTOKEN
+tokenize.Expfloat
+tokenize.Exponent
+tokenize.Floatnumber
+tokenize.Funny
+tokenize.GREATER
+tokenize.GREATEREQUAL
+tokenize.Hexnumber
+tokenize.INDENT
+tokenize.ISEOF(??)
+tokenize.ISNONTERMINAL(??)
+tokenize.ISTERMINAL(??)
+tokenize.Ignore
+tokenize.Imagnumber
+tokenize.Intnumber
+tokenize.LBRACE
+tokenize.LEFTSHIFT
+tokenize.LEFTSHIFTEQUAL
+tokenize.LESS
+tokenize.LESSEQUAL
+tokenize.LPAR
+tokenize.LSQB
+tokenize.MINEQUAL
+tokenize.MINUS
+tokenize.NAME
+tokenize.NEWLINE
+tokenize.NL
+tokenize.NOTEQUAL
+tokenize.NT_OFFSET
+tokenize.NUMBER
+tokenize.N_TOKENS
+tokenize.Name
+tokenize.Number
+tokenize.OP
+tokenize.Octnumber
+tokenize.Operator
+tokenize.PERCENT
+tokenize.PERCENTEQUAL
+tokenize.PLUS
+tokenize.PLUSEQUAL
+tokenize.PlainToken
+tokenize.Pointfloat
+tokenize.PseudoExtras
+tokenize.PseudoToken
+tokenize.RBRACE
+tokenize.RIGHTSHIFT
+tokenize.RIGHTSHIFTEQUAL
+tokenize.RPAR
+tokenize.RSQB
+tokenize.SEMI
+tokenize.SLASH
+tokenize.SLASHEQUAL
+tokenize.STAR
+tokenize.STAREQUAL
+tokenize.STRING
+tokenize.Single
+tokenize.Single3
+tokenize.Special
+tokenize.StopTokenizing(??)
+tokenize.String
+tokenize.TILDE
+tokenize.Token
+tokenize.TokenError(??)
+tokenize.Triple
+tokenize.VBAR
+tokenize.VBAREQUAL
+tokenize.Whitespace
+tokenize.any(??)
+tokenize.double3prog
+tokenize.endprogs
+tokenize.generate_tokens(??)
+tokenize.group(??)
+tokenize.main(??)
+tokenize.maybe(??)
+tokenize.printtoken(??)
+tokenize.pseudoprog
+tokenize.re
+tokenize.single3prog
+tokenize.single_quoted
+tokenize.string
+tokenize.t
+tokenize.tabsize
+tokenize.tok_name
+tokenize.tokenize(??)
+tokenize.tokenize_loop(??)
+tokenize.tokenprog
+tokenize.triple_quoted
+trace.CoverageResults(??)
+trace.Ignore(??)
+trace.PRAGMA_NOCOVER
+trace.Trace(??)
+trace.cPickle
+trace.find_executable_linenos(??)
+trace.find_lines(??)
+trace.find_lines_from_code(??)
+trace.find_strings(??)
+trace.fullmodname(??)
+trace.gc
+trace.linecache
+trace.main(??)
+trace.modname(??)
+trace.os
+trace.pickle
+trace.re
+trace.rx_blank
+trace.sys
+trace.threading
+trace.token
+trace.tokenize
+trace.types
+trace.usage(??)
+traceback.extract_stack(??)
+traceback.extract_tb(??)
+traceback.format_exc(??)
+traceback.format_exception(??)
+traceback.format_exception_only(??)
+traceback.format_list(??)
+traceback.format_stack(??)
+traceback.format_tb(??)
+traceback.linecache
+traceback.print_exc(??)
+traceback.print_exception(??)
+traceback.print_last(??)
+traceback.print_list(??)
+traceback.print_stack(??)
+traceback.print_tb(??)
+traceback.sys
+traceback.tb_lineno(??)
+traceback.types
+tty.B0
+tty.B110
+tty.B115200
+tty.B1200
+tty.B134
+tty.B150
+tty.B1800
+tty.B19200
+tty.B200
+tty.B230400
+tty.B2400
+tty.B300
+tty.B38400
+tty.B460800
+tty.B4800
+tty.B50
+tty.B57600
+tty.B600
+tty.B75
+tty.B9600
+tty.BRKINT
+tty.BS0
+tty.BS1
+tty.BSDLY
+tty.CBAUD
+tty.CBAUDEX
+tty.CC
+tty.CDSUSP
+tty.CEOF
+tty.CEOL
+tty.CEOT
+tty.CERASE
+tty.CFLAG
+tty.CFLUSH
+tty.CIBAUD
+tty.CINTR
+tty.CKILL
+tty.CLNEXT
+tty.CLOCAL
+tty.CQUIT
+tty.CR0
+tty.CR1
+tty.CR2
+tty.CR3
+tty.CRDLY
+tty.CREAD
+tty.CRPRNT
+tty.CRTSCTS
+tty.CS5
+tty.CS6
+tty.CS7
+tty.CS8
+tty.CSIZE
+tty.CSTART
+tty.CSTOP
+tty.CSTOPB
+tty.CSUSP
+tty.CWERASE
+tty.ECHO
+tty.ECHOCTL
+tty.ECHOE
+tty.ECHOK
+tty.ECHOKE
+tty.ECHONL
+tty.ECHOPRT
+tty.EXTA
+tty.EXTB
+tty.FF0
+tty.FF1
+tty.FFDLY
+tty.FIOASYNC
+tty.FIOCLEX
+tty.FIONBIO
+tty.FIONCLEX
+tty.FIONREAD
+tty.FLUSHO
+tty.HUPCL
+tty.ICANON
+tty.ICRNL
+tty.IEXTEN
+tty.IFLAG
+tty.IGNBRK
+tty.IGNCR
+tty.IGNPAR
+tty.IMAXBEL
+tty.INLCR
+tty.INPCK
+tty.IOCSIZE_MASK
+tty.IOCSIZE_SHIFT
+tty.ISIG
+tty.ISPEED
+tty.ISTRIP
+tty.IUCLC
+tty.IXANY
+tty.IXOFF
+tty.IXON
+tty.LFLAG
+tty.NCC
+tty.NCCS
+tty.NL0
+tty.NL1
+tty.NLDLY
+tty.NOFLSH
+tty.N_MOUSE
+tty.N_PPP
+tty.N_SLIP
+tty.N_STRIP
+tty.N_TTY
+tty.OCRNL
+tty.OFDEL
+tty.OFILL
+tty.OFLAG
+tty.OLCUC
+tty.ONLCR
+tty.ONLRET
+tty.ONOCR
+tty.OPOST
+tty.OSPEED
+tty.PARENB
+tty.PARMRK
+tty.PARODD
+tty.PENDIN
+tty.TAB0
+tty.TAB1
+tty.TAB2
+tty.TAB3
+tty.TABDLY
+tty.TCFLSH
+tty.TCGETA
+tty.TCGETS
+tty.TCIFLUSH
+tty.TCIOFF
+tty.TCIOFLUSH
+tty.TCION
+tty.TCOFLUSH
+tty.TCOOFF
+tty.TCOON
+tty.TCSADRAIN
+tty.TCSAFLUSH
+tty.TCSANOW
+tty.TCSBRK
+tty.TCSBRKP
+tty.TCSETA
+tty.TCSETAF
+tty.TCSETAW
+tty.TCSETS
+tty.TCSETSF
+tty.TCSETSW
+tty.TCXONC
+tty.TIOCCONS
+tty.TIOCEXCL
+tty.TIOCGETD
+tty.TIOCGICOUNT
+tty.TIOCGLCKTRMIOS
+tty.TIOCGPGRP
+tty.TIOCGSERIAL
+tty.TIOCGSOFTCAR
+tty.TIOCGWINSZ
+tty.TIOCINQ
+tty.TIOCLINUX
+tty.TIOCMBIC
+tty.TIOCMBIS
+tty.TIOCMGET
+tty.TIOCMIWAIT
+tty.TIOCMSET
+tty.TIOCM_CAR
+tty.TIOCM_CD
+tty.TIOCM_CTS
+tty.TIOCM_DSR
+tty.TIOCM_DTR
+tty.TIOCM_LE
+tty.TIOCM_RI
+tty.TIOCM_RNG
+tty.TIOCM_RTS
+tty.TIOCM_SR
+tty.TIOCM_ST
+tty.TIOCNOTTY
+tty.TIOCNXCL
+tty.TIOCOUTQ
+tty.TIOCPKT
+tty.TIOCPKT_DATA
+tty.TIOCPKT_DOSTOP
+tty.TIOCPKT_FLUSHREAD
+tty.TIOCPKT_FLUSHWRITE
+tty.TIOCPKT_NOSTOP
+tty.TIOCPKT_START
+tty.TIOCPKT_STOP
+tty.TIOCSCTTY
+tty.TIOCSERCONFIG
+tty.TIOCSERGETLSR
+tty.TIOCSERGETMULTI
+tty.TIOCSERGSTRUCT
+tty.TIOCSERGWILD
+tty.TIOCSERSETMULTI
+tty.TIOCSERSWILD
+tty.TIOCSER_TEMT
+tty.TIOCSETD
+tty.TIOCSLCKTRMIOS
+tty.TIOCSPGRP
+tty.TIOCSSERIAL
+tty.TIOCSSOFTCAR
+tty.TIOCSTI
+tty.TIOCSWINSZ
+tty.TOSTOP
+tty.VDISCARD
+tty.VEOF
+tty.VEOL
+tty.VEOL2
+tty.VERASE
+tty.VINTR
+tty.VKILL
+tty.VLNEXT
+tty.VMIN
+tty.VQUIT
+tty.VREPRINT
+tty.VSTART
+tty.VSTOP
+tty.VSUSP
+tty.VSWTC
+tty.VSWTCH
+tty.VT0
+tty.VT1
+tty.VTDLY
+tty.VTIME
+tty.VWERASE
+tty.XCASE
+tty.XTABS
+tty.error(??)
+tty.setcbreak(??)
+tty.setraw(??)
+tty.tcdrain(fd) -> None
+tty.tcflow(fd, action) -> None
+tty.tcflush(fd, queue) -> None
+tty.tcgetattr(fd) -> list_of_attrs
+tty.tcsendbreak(fd, duration) -> None
+tty.tcsetattr(fd, when, attributes) -> None
+tuple() -> an empty tuple
+type(object) -> the object's type
+types.BooleanType
+types.BufferType
+types.BuiltinFunctionType
+types.BuiltinMethodType
+types.ClassType
+types.CodeType
+types.ComplexType
+types.DictProxyType
+types.DictType
+types.DictionaryType
+types.EllipsisType
+types.FileType
+types.FloatType
+types.FrameType
+types.FunctionType
+types.GeneratorType
+types.InstanceType
+types.IntType
+types.LambdaType
+types.ListType
+types.LongType
+types.MethodType
+types.ModuleType
+types.NoneType
+types.NotImplementedType
+types.ObjectType
+types.SliceType
+types.StringType
+types.StringTypes
+types.TracebackType
+types.TupleType
+types.TypeType
+types.UnboundMethodType
+types.UnicodeType
+types.XRangeType
+unichr(i) -> Unicode character
+unicode(string [, encoding[, errors]]) -> object
+unicodedata.bidirectional
+unicodedata.category
+unicodedata.combining
+unicodedata.decimal
+unicodedata.decomposition
+unicodedata.digit
+unicodedata.east_asian_width
+unicodedata.lookup
+unicodedata.mirrored
+unicodedata.name
+unicodedata.normalize
+unicodedata.numeric
+unicodedata.ucnhash_CAPI
+unicodedata.unidata_version
+unittest.FunctionTestCase
+unittest.TestCase
+unittest.TestLoader
+unittest.TestProgram
+unittest.TestResult
+unittest.TestSuite
+unittest.TextTestRunner
+unittest.defaultTestLoader
+unittest.findTestCases(??)
+unittest.getTestCaseNames(??)
+unittest.main
+unittest.makeSuite(??)
+unittest.os
+unittest.sys
+unittest.time
+unittest.traceback
+unittest.types
+urllib.ContentTooShortError(??)
+urllib.FancyURLopener(??)
+urllib.MAXFTPCACHE
+urllib.URLopener(??)
+urllib.addbase(??)
+urllib.addclosehook(??)
+urllib.addinfo(??)
+urllib.addinfourl(??)
+urllib.always_safe
+urllib.basejoin(??)
+urllib.ftpcache
+urllib.ftperrors(??)
+urllib.ftpwrapper(??)
+urllib.getproxies(??)
+urllib.getproxies_environment(??)
+urllib.localhost(??)
+urllib.main(??)
+urllib.noheaders(??)
+urllib.os
+urllib.pathname2url(??)
+urllib.proxy_bypass(??)
+urllib.quote('abc def') -> 'abc%20def'
+urllib.quote_plus(??)
+urllib.reporthook(??)
+urllib.socket
+urllib.splitattr('/path;attr1=value1;attr2=value2;...') ->
+urllib.splitgophertype('/Xselector') --> 'X', 'selector'.
+urllib.splithost('//host[:port]/path') --> 'host[:port]', '/path'.
+urllib.splitnport(??)
+urllib.splitpasswd('user:passwd') -> 'user', 'passwd'.
+urllib.splitport('host:port') --> 'host', 'port'.
+urllib.splitquery('/path?query') --> '/path', 'query'.
+urllib.splittag('/path#tag') --> '/path', 'tag'.
+urllib.splittype('type:opaquestring') --> 'type', 'opaquestring'.
+urllib.splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'.
+urllib.splitvalue('attr=value') --> 'attr', 'value'.
+urllib.string
+urllib.sys
+urllib.test(??)
+urllib.test1(??)
+urllib.thishost(??)
+urllib.time
+urllib.toBytes(u"URL") --> 'URL'.
+urllib.unquote('abc%20def') -> 'abc def'.
+urllib.unquote_plus(??)
+urllib.unwrap('<URL:type://host/path>') --> 'type://host/path'.
+urllib.url2pathname(??)
+urllib.urlcleanup(??)
+urllib.urlencode(??)
+urllib.urlopen(url [, data]) -> open file-like object
+urllib.urlretrieve(??)
+urllib2.AbstractBasicAuthHandler(??)
+urllib2.AbstractDigestAuthHandler(??)
+urllib2.AbstractHTTPHandler(??)
+urllib2.BaseHandler(??)
+urllib2.CacheFTPHandler(??)
+urllib2.CustomProxy(??)
+urllib2.CustomProxyHandler(??)
+urllib2.FTPHandler(??)
+urllib2.FileHandler(??)
+urllib2.GopherError(??)
+urllib2.GopherHandler(??)
+urllib2.HTTPBasicAuthHandler(??)
+urllib2.HTTPCookieProcessor(??)
+urllib2.HTTPDefaultErrorHandler(??)
+urllib2.HTTPDigestAuthHandler(??)
+urllib2.HTTPError(??)
+urllib2.HTTPErrorProcessor(??)
+urllib2.HTTPHandler(??)
+urllib2.HTTPPasswordMgr(??)
+urllib2.HTTPPasswordMgrWithDefaultRealm(??)
+urllib2.HTTPRedirectHandler(??)
+urllib2.HTTPSHandler(??)
+urllib2.OpenerDirector(??)
+urllib2.OpenerFactory(??)
+urllib2.ProxyBasicAuthHandler(??)
+urllib2.ProxyDigestAuthHandler(??)
+urllib2.ProxyHandler(??)
+urllib2.Request(??)
+urllib2.StringIO([s]) -- Return a StringIO-like stream for reading or writing
+urllib2.URLError(??)
+urllib2.UnknownHandler(??)
+urllib2.addinfourl(??)
+urllib2.base64
+urllib2.bisect
+urllib2.build_opener(??)
+urllib2.cookielib
+urllib2.ftplib
+urllib2.ftpwrapper(??)
+urllib2.getproxies(??)
+urllib2.gopherlib
+urllib2.httplib
+urllib2.inspect
+urllib2.install_opener(??)
+urllib2.localhost(??)
+urllib2.md5
+urllib2.mimetools
+urllib2.mimetypes
+urllib2.noheaders(??)
+urllib2.os
+urllib2.parse_http_list(??)
+urllib2.parse_keqv_list(??)
+urllib2.posixpath
+urllib2.random
+urllib2.randombytes(??)
+urllib2.re
+urllib2.sha
+urllib2.socket
+urllib2.splitattr('/path;attr1=value1;attr2=value2;...') ->
+urllib2.splitgophertype('/Xselector') --> 'X', 'selector'.
+urllib2.splithost('//host[:port]/path') --> 'host[:port]', '/path'.
+urllib2.splitpasswd('user:passwd') -> 'user', 'passwd'.
+urllib2.splitport('host:port') --> 'host', 'port'.
+urllib2.splitquery('/path?query') --> '/path', 'query'.
+urllib2.splittype('type:opaquestring') --> 'type', 'opaquestring'.
+urllib2.splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'.
+urllib2.splitvalue('attr=value') --> 'attr', 'value'.
+urllib2.sys
+urllib2.time
+urllib2.unquote('abc%20def') -> 'abc def'.
+urllib2.unwrap('<URL:type://host/path>') --> 'type://host/path'.
+urllib2.url2pathname(??)
+urllib2.urlopen(??)
+urllib2.urlparse
+urlparse.MAX_CACHE_SIZE
+urlparse.clear_cache(??)
+urlparse.non_hierarchical
+urlparse.scheme_chars
+urlparse.test(??)
+urlparse.test_input
+urlparse.urldefrag(??)
+urlparse.urljoin(??)
+urlparse.urlparse(??)
+urlparse.urlsplit(??)
+urlparse.urlunparse(??)
+urlparse.urlunsplit(??)
+urlparse.uses_fragment
+urlparse.uses_netloc
+urlparse.uses_params
+urlparse.uses_query
+urlparse.uses_relative
+user.home
+user.os
+user.pythonrc
+uu.Error(??)
+uu.StringType
+uu.binascii
+uu.decode(??)
+uu.encode(??)
+uu.os
+uu.sys
+uu.test(??)
+vars([object]) -> dictionary
+warnings.defaultaction
+warnings.filters
+warnings.filterwarnings(??)
+warnings.formatwarning(??)
+warnings.linecache
+warnings.onceregistry
+warnings.resetwarnings(??)
+warnings.showwarning(??)
+warnings.simplefilter(??)
+warnings.sys
+warnings.types
+warnings.warn(??)
+warnings.warn_explicit(??)
+wave.Chunk(??)
+wave.Error(??)
+wave.WAVE_FORMAT_PCM
+wave.Wave_read(??)
+wave.Wave_write(??)
+wave.big_endian
+wave.open(??)
+wave.openfp(??)
+wave.struct
+weakref.CallableProxyType
+weakref.KeyedRef
+weakref.ProxyType
+weakref.ProxyTypes
+weakref.ReferenceError(??)
+weakref.ReferenceType
+weakref.UserDict
+weakref.WeakKeyDictionary(??)
+weakref.WeakValueDictionary(??)
+weakref.getweakrefcount(object) -- return the number of weak references
+weakref.getweakrefs(object) -- return a list of all weak reference objects
+weakref.proxy(object[, callback]) -- create a proxy object that weakly
+weakref.ref
+webbrowser.Error(??)
+webbrowser.Galeon(??)
+webbrowser.GenericBrowser(??)
+webbrowser.Grail(??)
+webbrowser.InternetConfig(??)
+webbrowser.Konqueror(??)
+webbrowser.Netscape(??)
+webbrowser.PROCESS_CREATION_DELAY
+webbrowser.WindowsDefault(??)
+webbrowser.browser
+webbrowser.get(??)
+webbrowser.open(??)
+webbrowser.open_new(??)
+webbrowser.os
+webbrowser.register(??)
+webbrowser.sys
+whichdb.dbm
+whichdb.os
+whichdb.struct
+whichdb.sys
+whichdb.whichdb(??)
+whrandom.choice
+whrandom.randint
+whrandom.random
+whrandom.randrange
+whrandom.seed
+whrandom.uniform
+whrandom.warnings
+whrandom.whrandom(??)
+xdrlib.ConversionError(??)
+xdrlib.Error(??)
+xdrlib.Packer(??)
+xdrlib.Unpacker(??)
+xdrlib.struct
+xml.dom
+xml.dom.DOMException(??)
+xml.dom.DOMSTRING_SIZE_ERR
+xml.dom.DomstringSizeErr(??)
+xml.dom.EMPTY_NAMESPACE
+xml.dom.EMPTY_PREFIX
+xml.dom.HIERARCHY_REQUEST_ERR
+xml.dom.HierarchyRequestErr(??)
+xml.dom.INDEX_SIZE_ERR
+xml.dom.INUSE_ATTRIBUTE_ERR
+xml.dom.INVALID_ACCESS_ERR
+xml.dom.INVALID_CHARACTER_ERR
+xml.dom.INVALID_MODIFICATION_ERR
+xml.dom.INVALID_STATE_ERR
+xml.dom.IndexSizeErr(??)
+xml.dom.InuseAttributeErr(??)
+xml.dom.InvalidAccessErr(??)
+xml.dom.InvalidCharacterErr(??)
+xml.dom.InvalidModificationErr(??)
+xml.dom.InvalidStateErr(??)
+xml.dom.NAMESPACE_ERR
+xml.dom.NOT_FOUND_ERR
+xml.dom.NOT_SUPPORTED_ERR
+xml.dom.NO_DATA_ALLOWED_ERR
+xml.dom.NO_MODIFICATION_ALLOWED_ERR
+xml.dom.NamespaceErr(??)
+xml.dom.NoDataAllowedErr(??)
+xml.dom.NoModificationAllowedErr(??)
+xml.dom.Node(??)
+xml.dom.NodeFilter
+xml.dom.NodeFilter.NodeFilter(??)
+xml.dom.NotFoundErr(??)
+xml.dom.NotSupportedErr(??)
+xml.dom.SYNTAX_ERR
+xml.dom.SyntaxErr(??)
+xml.dom.UserDataHandler(??)
+xml.dom.VALIDATION_ERR
+xml.dom.ValidationErr(??)
+xml.dom.WRONG_DOCUMENT_ERR
+xml.dom.WrongDocumentErr(??)
+xml.dom.XHTML_NAMESPACE
+xml.dom.XMLNS_NAMESPACE
+xml.dom.XML_NAMESPACE
+xml.dom.domreg
+xml.dom.domreg.EmptyNodeList
+xml.dom.domreg.GetattrMagic(??)
+xml.dom.domreg.NewStyle
+xml.dom.domreg.NodeList
+xml.dom.domreg.StringTypes
+xml.dom.domreg.defproperty(??)
+xml.dom.domreg.getDOMImplementation(name = None, features = ()) -> DOM implementation.
+xml.dom.domreg.registerDOMImplementation(name, factory)
+xml.dom.domreg.registered
+xml.dom.domreg.well_known_implementations
+xml.dom.expatbuilder
+xml.dom.expatbuilder.CDATA_SECTION_NODE
+xml.dom.expatbuilder.DOCUMENT_NODE
+xml.dom.expatbuilder.EMPTY_NAMESPACE
+xml.dom.expatbuilder.EMPTY_PREFIX
+xml.dom.expatbuilder.ElementInfo
+xml.dom.expatbuilder.EmptyNodeList
+xml.dom.expatbuilder.ExpatBuilder(??)
+xml.dom.expatbuilder.ExpatBuilderNS(??)
+xml.dom.expatbuilder.FILTER_ACCEPT
+xml.dom.expatbuilder.FILTER_INTERRUPT
+xml.dom.expatbuilder.FILTER_REJECT
+xml.dom.expatbuilder.FILTER_SKIP
+xml.dom.expatbuilder.FilterCrutch
+xml.dom.expatbuilder.FilterVisibilityController
+xml.dom.expatbuilder.FragmentBuilder(??)
+xml.dom.expatbuilder.FragmentBuilderNS(??)
+xml.dom.expatbuilder.GetattrMagic(??)
+xml.dom.expatbuilder.InternalSubsetExtractor(??)
+xml.dom.expatbuilder.Namespaces(??)
+xml.dom.expatbuilder.NewStyle
+xml.dom.expatbuilder.Node(??)
+xml.dom.expatbuilder.NodeFilter(??)
+xml.dom.expatbuilder.NodeList
+xml.dom.expatbuilder.ParseEscape(??)
+xml.dom.expatbuilder.Rejecter
+xml.dom.expatbuilder.Skipper
+xml.dom.expatbuilder.StringTypes
+xml.dom.expatbuilder.TEXT_NODE
+xml.dom.expatbuilder.XMLNS_NAMESPACE
+xml.dom.expatbuilder.defproperty(??)
+xml.dom.expatbuilder.expat
+xml.dom.expatbuilder.makeBuilder(??)
+xml.dom.expatbuilder.minidom
+xml.dom.expatbuilder.parse(??)
+xml.dom.expatbuilder.parseFragment(??)
+xml.dom.expatbuilder.parseFragmentString(??)
+xml.dom.expatbuilder.parseString(??)
+xml.dom.expatbuilder.theDOMImplementation
+xml.dom.expatbuilder.xmlbuilder
+xml.dom.getDOMImplementation(name = None, features = ()) -> DOM implementation.
+xml.dom.minicompat
+xml.dom.minicompat.EmptyNodeList
+xml.dom.minicompat.GetattrMagic(??)
+xml.dom.minicompat.NewStyle
+xml.dom.minicompat.NodeList
+xml.dom.minicompat.StringTypes
+xml.dom.minicompat.defproperty(??)
+xml.dom.minicompat.xml
+xml.dom.minidom
+xml.dom.minidom.Attr(??)
+xml.dom.minidom.AttributeList
+xml.dom.minidom.CDATASection(??)
+xml.dom.minidom.CharacterData(??)
+xml.dom.minidom.Childless(??)
+xml.dom.minidom.Comment(??)
+xml.dom.minidom.DOMImplementation(??)
+xml.dom.minidom.DOMImplementationLS(??)
+xml.dom.minidom.Document(??)
+xml.dom.minidom.DocumentFragment(??)
+xml.dom.minidom.DocumentLS(??)
+xml.dom.minidom.DocumentType(??)
+xml.dom.minidom.EMPTY_NAMESPACE
+xml.dom.minidom.EMPTY_PREFIX
+xml.dom.minidom.Element(??)
+xml.dom.minidom.ElementInfo
+xml.dom.minidom.EmptyNodeList
+xml.dom.minidom.Entity(??)
+xml.dom.minidom.GetattrMagic(??)
+xml.dom.minidom.Identified(??)
+xml.dom.minidom.NamedNodeMap
+xml.dom.minidom.NewStyle
+xml.dom.minidom.Node(??)
+xml.dom.minidom.NodeList
+xml.dom.minidom.Notation(??)
+xml.dom.minidom.ProcessingInstruction(??)
+xml.dom.minidom.ReadOnlySequentialNamedNodeMap
+xml.dom.minidom.StringTypes
+xml.dom.minidom.Text(??)
+xml.dom.minidom.TypeInfo
+xml.dom.minidom.XMLNS_NAMESPACE
+xml.dom.minidom.defproperty(??)
+xml.dom.minidom.domreg
+xml.dom.minidom.getDOMImplementation(??)
+xml.dom.minidom.parse(??)
+xml.dom.minidom.parseString(??)
+xml.dom.minidom.xml
+xml.dom.pulldom
+xml.dom.pulldom.CHARACTERS
+xml.dom.pulldom.COMMENT
+xml.dom.pulldom.DOMEventStream(??)
+xml.dom.pulldom.END_DOCUMENT
+xml.dom.pulldom.END_ELEMENT
+xml.dom.pulldom.ErrorHandler(??)
+xml.dom.pulldom.IGNORABLE_WHITESPACE
+xml.dom.pulldom.PROCESSING_INSTRUCTION
+xml.dom.pulldom.PullDOM(??)
+xml.dom.pulldom.SAX2DOM(??)
+xml.dom.pulldom.START_DOCUMENT
+xml.dom.pulldom.START_ELEMENT
+xml.dom.pulldom.default_bufsize
+xml.dom.pulldom.parse(??)
+xml.dom.pulldom.parseString(??)
+xml.dom.pulldom.types
+xml.dom.pulldom.xml
+xml.dom.registerDOMImplementation(name, factory)
+xml.dom.xmlbuilder
+xml.dom.xmlbuilder.DOMBuilder(??)
+xml.dom.xmlbuilder.DOMBuilderFilter(??)
+xml.dom.xmlbuilder.DOMEntityResolver
+xml.dom.xmlbuilder.DOMImplementationLS(??)
+xml.dom.xmlbuilder.DOMInputSource
+xml.dom.xmlbuilder.DocumentLS(??)
+xml.dom.xmlbuilder.EmptyNodeList
+xml.dom.xmlbuilder.GetattrMagic(??)
+xml.dom.xmlbuilder.NewStyle
+xml.dom.xmlbuilder.NodeList
+xml.dom.xmlbuilder.Options(??)
+xml.dom.xmlbuilder.StringTypes
+xml.dom.xmlbuilder.copy
+xml.dom.xmlbuilder.defproperty(??)
+xml.dom.xmlbuilder.xml
+xml.parsers
+xml.parsers.expat
+xml.parsers.expat.EXPAT_VERSION
+xml.parsers.expat.ErrorString(errno) -> string
+xml.parsers.expat.ExpatError(??)
+xml.parsers.expat.ParserCreate([encoding[, namespace_separator]]) -> parser
+xml.parsers.expat.XMLParserType
+xml.parsers.expat.XML_PARAM_ENTITY_PARSING_ALWAYS
+xml.parsers.expat.XML_PARAM_ENTITY_PARSING_NEVER
+xml.parsers.expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
+xml.parsers.expat.error(??)
+xml.parsers.expat.errors
+xml.parsers.expat.features
+xml.parsers.expat.model
+xml.parsers.expat.native_encoding
+xml.parsers.expat.version_info
+xml.sax
+xml.sax.ContentHandler(??)
+xml.sax.ErrorHandler(??)
+xml.sax.InputSource(??)
+xml.sax.SAXException(??)
+xml.sax.SAXNotRecognizedException(??)
+xml.sax.SAXNotSupportedException(??)
+xml.sax.SAXParseException(??)
+xml.sax.SAXReaderNotAvailable(??)
+xml.sax.default_parser_list
+xml.sax.expatreader
+xml.sax.expatreader.AttributesImpl(??)
+xml.sax.expatreader.AttributesNSImpl(??)
+xml.sax.expatreader.ExpatLocator(??)
+xml.sax.expatreader.ExpatParser(??)
+xml.sax.expatreader.SAXException(??)
+xml.sax.expatreader.SAXNotRecognizedException(??)
+xml.sax.expatreader.SAXNotSupportedException(??)
+xml.sax.expatreader.SAXParseException(??)
+xml.sax.expatreader.SAXReaderNotAvailable(??)
+xml.sax.expatreader.create_parser(??)
+xml.sax.expatreader.expat
+xml.sax.expatreader.feature_external_ges
+xml.sax.expatreader.feature_external_pes
+xml.sax.expatreader.feature_namespace_prefixes
+xml.sax.expatreader.feature_namespaces
+xml.sax.expatreader.feature_string_interning
+xml.sax.expatreader.feature_validation
+xml.sax.expatreader.handler
+xml.sax.expatreader.property_interning_dict
+xml.sax.expatreader.property_xml_string
+xml.sax.expatreader.saxutils
+xml.sax.expatreader.version
+xml.sax.expatreader.xmlreader
+xml.sax.handler
+xml.sax.handler.ContentHandler(??)
+xml.sax.handler.DTDHandler(??)
+xml.sax.handler.EntityResolver(??)
+xml.sax.handler.ErrorHandler(??)
+xml.sax.handler.all_features
+xml.sax.handler.all_properties
+xml.sax.handler.feature_external_ges
+xml.sax.handler.feature_external_pes
+xml.sax.handler.feature_namespace_prefixes
+xml.sax.handler.feature_namespaces
+xml.sax.handler.feature_string_interning
+xml.sax.handler.feature_validation
+xml.sax.handler.property_declaration_handler
+xml.sax.handler.property_dom_node
+xml.sax.handler.property_encoding
+xml.sax.handler.property_interning_dict
+xml.sax.handler.property_lexical_handler
+xml.sax.handler.property_xml_string
+xml.sax.handler.version
+xml.sax.make_parser(??)
+xml.sax.parse(??)
+xml.sax.parseString(??)
+xml.sax.saxutils
+xml.sax.saxutils.XMLFilterBase(??)
+xml.sax.saxutils.XMLGenerator(??)
+xml.sax.saxutils.escape(??)
+xml.sax.saxutils.handler
+xml.sax.saxutils.os
+xml.sax.saxutils.prepare_input_source(??)
+xml.sax.saxutils.quoteattr(??)
+xml.sax.saxutils.types
+xml.sax.saxutils.unescape(??)
+xml.sax.saxutils.urllib
+xml.sax.saxutils.urlparse
+xml.sax.saxutils.xmlreader
+xml.sax.xmlreader
+xml.sax.xmlreader.AttributesImpl(??)
+xml.sax.xmlreader.AttributesNSImpl(??)
+xml.sax.xmlreader.IncrementalParser(??)
+xml.sax.xmlreader.InputSource(??)
+xml.sax.xmlreader.Locator(??)
+xml.sax.xmlreader.SAXNotRecognizedException(??)
+xml.sax.xmlreader.SAXNotSupportedException(??)
+xml.sax.xmlreader.XMLReader(??)
+xml.sax.xmlreader.handler
+xmllib.Error(??)
+xmllib.TestXMLParser(??)
+xmllib.XMLParser(??)
+xmllib.amp
+xmllib.attrfind
+xmllib.attrtrans
+xmllib.cdataclose
+xmllib.cdataopen
+xmllib.charref
+xmllib.commentclose
+xmllib.commentopen
+xmllib.doctype
+xmllib.doubledash
+xmllib.endbracket
+xmllib.endbracketfind
+xmllib.endtagopen
+xmllib.entityref
+xmllib.illegal
+xmllib.interesting
+xmllib.ncname
+xmllib.newline
+xmllib.procclose
+xmllib.procopen
+xmllib.qname
+xmllib.re
+xmllib.ref
+xmllib.space
+xmllib.starttagend
+xmllib.starttagmatch
+xmllib.starttagopen
+xmllib.string
+xmllib.tagfind
+xmllib.test(??)
+xmllib.version
+xmllib.xmldecl
+xmllib.xmlns
+xmlrpclib.APPLICATION_ERROR
+xmlrpclib.Binary(??)
+xmlrpclib.Boolean
+xmlrpclib.BooleanType
+xmlrpclib.BufferType
+xmlrpclib.BuiltinFunctionType
+xmlrpclib.BuiltinMethodType
+xmlrpclib.ClassType
+xmlrpclib.CodeType
+xmlrpclib.ComplexType
+xmlrpclib.DateTime(??)
+xmlrpclib.DictProxyType
+xmlrpclib.DictType
+xmlrpclib.DictionaryType
+xmlrpclib.EllipsisType
+xmlrpclib.Error(??)
+xmlrpclib.ExpatParser(??)
+xmlrpclib.False
+xmlrpclib.FastMarshaller
+xmlrpclib.FastParser
+xmlrpclib.FastUnmarshaller
+xmlrpclib.Fault(??)
+xmlrpclib.FileType
+xmlrpclib.FloatType
+xmlrpclib.FrameType
+xmlrpclib.FunctionType
+xmlrpclib.GeneratorType
+xmlrpclib.INTERNAL_ERROR
+xmlrpclib.INVALID_ENCODING_CHAR
+xmlrpclib.INVALID_METHOD_PARAMS
+xmlrpclib.INVALID_XMLRPC
+xmlrpclib.InstanceType
+xmlrpclib.IntType
+xmlrpclib.LambdaType
+xmlrpclib.ListType
+xmlrpclib.LongType
+xmlrpclib.MAXINT
+xmlrpclib.METHOD_NOT_FOUND
+xmlrpclib.MININT
+xmlrpclib.Marshaller(??)
+xmlrpclib.MethodType
+xmlrpclib.ModuleType
+xmlrpclib.MultiCall(??)
+xmlrpclib.MultiCallIterator(??)
+xmlrpclib.NOT_WELLFORMED_ERROR
+xmlrpclib.NoneType
+xmlrpclib.NotImplementedType
+xmlrpclib.ObjectType
+xmlrpclib.PARSE_ERROR
+xmlrpclib.ProtocolError(??)
+xmlrpclib.ResponseError(??)
+xmlrpclib.SERVER_ERROR
+xmlrpclib.SYSTEM_ERROR
+xmlrpclib.SafeTransport(??)
+xmlrpclib.Server(??)
+xmlrpclib.ServerProxy(??)
+xmlrpclib.SgmlopParser
+xmlrpclib.SliceType
+xmlrpclib.SlowParser(??)
+xmlrpclib.StringIO
+xmlrpclib.StringType
+xmlrpclib.StringTypes
+xmlrpclib.TRANSPORT_ERROR
+xmlrpclib.TracebackType
+xmlrpclib.Transport(??)
+xmlrpclib.True
+xmlrpclib.TupleType
+xmlrpclib.TypeType
+xmlrpclib.UNSUPPORTED_ENCODING
+xmlrpclib.UnboundMethodType
+xmlrpclib.UnicodeType
+xmlrpclib.Unmarshaller(??)
+xmlrpclib.WRAPPERS
+xmlrpclib.XRangeType
+xmlrpclib.base64
+xmlrpclib.boolean
+xmlrpclib.dumps(??)
+xmlrpclib.escape(??)
+xmlrpclib.expat
+xmlrpclib.getparser() -> parser, unmarshaller
+xmlrpclib.loads(??)
+xmlrpclib.operator
+xmlrpclib.re
+xmlrpclib.string
+xmlrpclib.time
+xrange([start,] stop[, step]) -> xrange object
+xxsubtype.bench
+xxsubtype.spamdict
+xxsubtype.spamlist
+zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]
+zipfile.BadZipfile(??)
+zipfile.PyZipFile(??)
+zipfile.ZIP_DEFLATED
+zipfile.ZIP_STORED
+zipfile.ZipFile(??)
+zipfile.ZipInfo(??)
+zipfile.binascii
+zipfile.error(??)
+zipfile.is_zipfile(??)
+zipfile.os
+zipfile.stringCentralDir
+zipfile.stringEndArchive
+zipfile.stringFileHeader
+zipfile.struct
+zipfile.structCentralDir
+zipfile.structEndArchive
+zipfile.structFileHeader
+zipfile.time
+zipfile.zlib
+zipimport.ZipImportError(??)
+zipimport.zipimporter(archivepath) -> zipimporter object
+zlib.DEFLATED
+zlib.DEF_MEM_LEVEL
+zlib.MAX_WBITS
+zlib.ZLIB_VERSION
+zlib.Z_BEST_COMPRESSION
+zlib.Z_BEST_SPEED
+zlib.Z_DEFAULT_COMPRESSION
+zlib.Z_DEFAULT_STRATEGY
+zlib.Z_FILTERED
+zlib.Z_FINISH
+zlib.Z_FULL_FLUSH
+zlib.Z_HUFFMAN_ONLY
+zlib.Z_NO_FLUSH
+zlib.Z_SYNC_FLUSH
+zlib.adler32(string[, start]) -- Compute an Adler-32 checksum of string.
+zlib.compress(string[, level]) -- Returned compressed string.
+zlib.compressobj([level]) -- Return a compressor object.
+zlib.crc32(string[, start]) -- Compute a CRC-32 checksum of string.
+zlib.decompress(string[, wbits[, bufsize]]) -- Return decompressed string.
+zlib.decompressobj([wbits]) -- Return a decompressor object.
+zlib.error(??)