#----------------------------------------------------------------------
# This file was generated by ../wxPython-2.3.2.1/tools/img2py.py
#
from wxPython.wx import wxBitmapFromXPMData, wxImageFromBitmap
import cPickle, zlib
from wxPython.wx import wxImageFromStream, wxBitmapFromImage
from wxPython.wx import wxEmptyIcon
import cStringIO



def getData_icon():
    return cPickle.loads(zlib.decompress(
'x\xda\x8d\xd2=k\xc30\x10\x06\xe0=\xbf\xe2\xc0\x02\x07\x0cBi\x12P7\xa5\x86\
\x8c\xd5\x90\xc5k\x08\x99\x1a\xaa\xfe\xff\xa9w\'\xf9C\xb6u\xf1\xc9\xcb+=\xbc\
6F\xfb\xd7\xdfaw\xab\x8f\x1f\x80\xcf\'\x1c\xea\xdd\xfdV\x03<\xe0\xebu\x7f\
\xfcp\n\x98\xaa\xd6\xb4\xa7\xd6p\xd6\x94\xcf\xf6b\xaf\x96sE\xd9\x1aZ\x9c={\
\x8b>\x9e7\x98\xbf\xc3\xef\x93CG\x87\xc6\x9cm*s\x94/\x86\x16gE\xf9j\rN\xfa\
\x14y\x12\xd28\x9bP\xd9\xf5\xaf\xd3\x12\xebQ\'\xa9\x01\rJ\x97\x91\xa8&hT\xba\
\x84$\x95\xa1\x92\x9a\xfc\xf1\x0c\x852\x1a\x95o\xd6Q\xa6\x82w4K4U\xa1\x89\
\xca\xad\xa2\xa8|\xf0\xa9\x8bX~U\xba\xc4\xb0\xa7\x19\xba\xdc\x0c%\xc5=\x93\
\xae\xf9\xa5C\xe2\\\xec\x19\xbb\x967\x93vC\xde\xb5r}\xab\n\xf7\xfb\xae\xe5/\
\xe8\x11\xab\xd8\xa4D\x84_\x86]\x8a\xa6\x80"\x0b\xd1(UB\xac\xd4;\x84\xa3\x04\
\x04s#!\x10\x11lB\xb0\t\xc1&D\n\xe0\x1d\x82\x19\xd2\xff\xeb\xe0\xee\x10' ))

def getBitmap_icon():
    return wxBitmapFromXPMData(getData_icon())

def getImage_icon():
    return wxImageFromBitmap(getBitmap_icon())

def getData_folder():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00" \xa1\xce\x95\x18\xac\xae\xad\x90\xac\xe0\x94\
\x93\x98\x9c\r\xe6E\x00y\xca\xce\x06 \x08\xe6\xe7\x83\xf8n\x16n\xce\x06\x10\
\xbe\x1e\x88oa\x00\x82`\xbe\x02\x90\xef\x97\x9f\x97\n\xe6\xf8\xc3\x14\xbbY@%\
Q\x01TP\x0f\x04\xd0\x04\xf5"\xf2\x81P\x0fE\x10"\x06\x14\x85j\x80\x08\xfa#\
\x01=m\x98`~\x04\x1c"\x04\x11b\x11\xf4W\x89\x02\xa0\x82\n\xda(@\x01_(a\x08\
\xea\x01\x00\x9c\xdeh<' ))

def getBitmap_folder():
    return wxBitmapFromXPMData(getData_folder())

def getImage_folder():
    return wxImageFromBitmap(getBitmap_folder())

def getData_folderopen():
    return cPickle.loads(zlib.decompress(
'x\xda}\x90\xb1\n\xc3 \x10\x86\xf7<\x85\xd0\xc1\xc2\xc1\x8fY\x8as\x03\x8eu\
\xc8\xe2\x1aB\xa7\x86\xda\xf7\x9f\xea\x9d\xd1h(\xfdO\x84\xef\xf3N\xc1\xeb\
\xf6\x19\x87Y\x8f7\x95V\xda\xf4\xb0\xcc\x9a\xd4\xaa\xee\xdb\xb2\xbe\x84b\xa2\
\xcbd\xb8\x84=\xb3\xb3n2\x99\xc1l\r\x97\xb0J\xfc\x88\xef\xa7@(\xcd\xce\xee\
\x87}\x8a\x04\xe7$\x118\xe8$B\xf4\xa9\x02\xf2@\x91>[\xe9\xa7\xae3\xd7.\xd1\
\xc6\x17\x19j@\xb5\xb3\x99&\xfc\xb8\x13t\xc8\xe3\x9d*[\x0b\xaa\xb2I\x95\x8a\
\xda\xfc\xfd\xa5\xb3\xc4\x17\xb0|c\xc2' ))

def getBitmap_folderopen():
    return wxBitmapFromXPMData(getData_folderopen())

def getImage_folderopen():
    return wxImageFromBitmap(getBitmap_folderopen())


def getData_text():
    return cPickle.loads(zlib.decompress(
'x\xda\xad\x8c\xbb\n\xc30\x0cE\xf7|\x85\xa0\x83\x0b\x06\xe1,Es\x03\x1e\xeb!\
\x8b\xd7\x10:5T\xfd\xff\xa9Wv\x1e\xa6]sd\x0c\xe7\xea\xa2\xeb\xf2\xe9\xbb\xd1\
\xf57\xc2\xc3\xe7\xbait\x9ef\xba/\xd3\xfc*\x96`\x97\x00$\x14W\xf3!\xd8\x14gs\
\t\xb2\xed\t\xfe\xd0\xf7\xb3H\xb6e\x948D\xa9K\xde!c\r\xf3\x8ar\x1bj\x1d\xcd\
\xdc6\x93\x91=\xf8k\xa2\xdb\x84\xf0\xda\xd5\x13\x9b)\x9d}S\x0f\xf6\xd0\xb7l\
\xe1\x0f\x08\xf9\x0b\xfc\x07n\x15' ))

def getBitmap_text():
    return wxBitmapFromXPMData(getData_text())

def getImage_text():
    return wxImageFromBitmap(getBitmap_text())

#----------------------------------------------------------------------
def getpyData():
    return zlib.decompress(
'x\xda\x01\xbf\x02@\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02vIDATx\x9c\x85\x92]HSq\x18\x87\x9f\xf3\xe1\
\x98\xba\xe3N\x1bMfL\x13\xa9HE\x03\xad\x9b\xbaQ\n\xd6\x07\x14d]\x14]\x05\x06\
\xa1]\x8c\xae\x8a\xa0\x88\xa4\xabn\xea\xd2I\t\x12\x04]D\x10\'\xe8\xb2.Rq,s;\
\xa6i:\xfch5\xa7\x96\xee\xeb\xec\x9c.\xc2eM\xe9\xb9\xfa\xff_^\x1e~/\xef+\xa8\
\xaa\xcaf\xfc~\xbf\xc5\x7f\xd04M\xd8x\xcb[5\xf4\xf4\xf4\x14\xd5\xa6\xc6G\xe9\
}\xf2\x94\xb6\xb66\x00kC\xb2\xa5\x00\xa0\xb6\xb6\xf6\xaf\xbf\xc3\xe1`\xe7\
\xab7tvvn\x94,M\xd3\x84m\x05\xff\xe2r\xb9\x90$\x89P(T\x90\xe8\xban\x15\t\xda\
\xdb\xdb\x01\x18x\xf1\x00\xc1\xfa=\xea\xd9\xe3W\xb1\xd9lx\xbd^\xfa\xfb\xfb\t\
\x06\x83D\xa3Q\x00$\xbb\xdd\xfe\x97\xc0Y\xfb\xf5\xb6\x9e\xec\xa3\xb1\xde\xc9\
D\xfc%n\x8f\x8c6\xf4\x90\xf9\xf98\x97\xceu\xd1\xdc\xd4\x88\xc7\xa5\xa0*\xe5\
\x84?F\x10TU\xe5T\x97\xd3\xb2\xcb">\x9f\x0fE\xc9\xb0[\x92YI\xbc\xa3d\xdf\t\
\x04\xa3\x0cC^B\xc8+\xcc\xc5\x04\xbaO\xf7\xf2c9A4\x12!p\xe3\x0e\xe2\xc5\x9b\
\x1e\xcbS\xbe\x8b\x0b\x1dg\xa8\xaevp\xa4\xf5(\xa3\xa3\x0bD\xdf\xc3\xc8h\x94\
\xe5\xf4\x17\x9cR\x036\xc7*\xc9L\x98\xbe\x81G(\xaa\x1b3\xbd\x08\x80\\b)\xeco\
QXJ&\xa8\xabj$\x19\x07*\xabQ\xaa\xdc\x1chi\xc6\x86\xcc\xe7\xd9\x05\xd6\xcc\
\x19\x8c,,J\xcfH\x7fk/\x8c,\xa8\xaa\xca\xdd\xe0!kzf\x9a\xf4\xbaI\xc3\xdezD\
\xa3\x82\xb9\xef\x93\xf8\xea\xd3D\xc2I\xf2\xa2LC\x93\xc8\xf8X\x8eR\x87\x88\
\xa9\x1f\xe6\xd8\xc1V\xae\xdf{\x8c\x08p\xeb\xf2\xa0\xf0a\xf0\'H\x02\xe1\x89\
\x10\x9f\x16\x86\x98\x9c\x9ec,\xb4\xc2\xea\xaa\x8c(YDG\x0cj\xf6\x94\x90Z6\
\x99]\x9e)$(\xacqXK\t\xc3Z\x8a@ `\x9d?\xd9\x81\x91Ia\xe63\xbc~;@2;A^\x19\'6e\
`\xaf\x10\xc9\x96\xc4\x8a\x05\x1bD"\x11l6;5^7y#\xc3\x95\xaak\x98F\x9a\xfb\
\xcf\xbbQw\xcc\x90\x13DD)[\xe8\x17\xb7\xbb\xbc\xbc\x91\xc6\xcc\xadc\x1a)\x8c\
\xcc\x1a\x82%\x11O\x08\x94\xda\xa1\xac\xac\x02\xd9Lo\x9d\x00`1\xa6\xb3\x18\
\x03\xd3X\xc7\xca\xa5\x98\x8c\x87\xa9\xac[A5D\x0cS\xc4a\xb9\x90%\xf1\xcf\x16\
6\xe3\xf7\xfb-]\xd7\xb7\x0bV\xc4/D\xe9\xf7\x89rd\xbb\xcd\x00\x00\x00\x00IEND\
\xaeB`\x82^/I\x0e' )

def getpyBitmap():
    return wxBitmapFromImage(getpyImage())

def getpyImage():
    stream = cStringIO.StringIO(getpyData())
    return wxImageFromStream(stream)

def getpyIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getpyBitmap())
    return icon

#----------------------------------------------------------------------
def getsourceData():
    return zlib.decompress(
'x\xda\x01\xe0\x01\x1f\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\
\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\
\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\x97IDATx\x9c\x85\x91OK\x1bQ\x14G\xcf8\
\x8a\x8b\x06\t\x01\x17A(\x04\xa4\xf8\x87\xe2F\x91\x16\x11\xb2K\xbfH\x16b\xe9\
\xde\x0f\x90]6.\x04\xc5@\x93.\xdcT\x08]\xb4\x03\x15i\x0b\xa5\x8b\x96f!tR\xc1\
\x16\xd4\x85\x1a]\x89\xbe\x99y\xf3\xdes\xa13I0\x93\xdc\xd5}\x97{\x0f\xbf\xc3\
\xb3\xd2\xe94\x9dU(\x14\x0c\x03\xcaq\x1c+\xea\x87{-\x94J\xa5G\xb3\x7f\x7f\
\x0f\xd8\xae\xee\x90\xcf\xe7\x01L\x04\xe9\t\x00\xc8\xe5r]\xefT*\xc5\xf8\xc7=\
\x8a\xc5b42\x8e\xe3X\x89\x80r\xb9\xcc\xcb\x85\x19^,\xbf\x02 \x93\xc9`\xdb6\
\x8dF#\x864\x9bM\x93\x08\xe8<\x06\xb0m\x9bl6K\xadV\xa3R\xa9\xe0\xba.}\x15:\
\x8f\xa3z\xbd\xba\xcae\xeb\x9cC\xf7\x80\xc9\xa7Y\xaa;\xef\x19\xea\xa7\xf0\
\xe3\xdb\xa7\xae~d\xd8"\x93\x1ecvz\x8a\xb9\xe7\xb3\x00\xbd\x01\x96eu)D\xbd\
\x92\x02\xa3\x04\xa3\xa36\xda;KV0\xc6\xc4\xc7\xc6h\xe6\x17\x97\xf1o\xaeP\xd2\
\x07\xed\xa3\xa5\x17\xef\x0eT\x08\x03\x81\x96\x02\x15xh)\xd8\xac\xd69\xfc\
\x7f\x0c\xca\xef\x0f\x88bk)P\xd2C\x87\x02\x1d\xdc\xb6\xd5T\x90\xac\x000\xbf\
\xb0\x84\x7f\xddB\x85\xde=\xe0\x01\xf2l\xe2\t\x17\xeeg\xd0\xb2\x7f\x82\xf5\
\x8d-~7~\xa1\x02\xc1\xd6\xbb\x0f\xfc9:E\x07\x82\xb7\xf5\x9f\x1c\xb5\xc28\xc1\
`\x85P\xb4\x7f!\xf4\xda\n\xdaOV8;i\x02\xf0}\x7f\x17#\x05F\n\xbe\xd6\xd7\xe3~\
\xbf\xfa\x05\xb4J\x06\xac\xbcYK\n\xf6\xa8\xee\x00qf\xcb\x1dX=\xaf\xfa\x00\
\x00\x00\x00IEND\xaeB`\x82t2\xcf\xef' )

def getsourceBitmap():
    return wxBitmapFromImage(getsourceImage())

def getsourceImage():
    stream = cStringIO.StringIO(getsourceData())
    return wxImageFromStream(stream)

def getsourceIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getsourceBitmap())
    return icon

#----------------------------------------------------------------------
def getcppData():
    return zlib.decompress(
'x\xda\x01\xcc\x013\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\x83IDATx\x9c\x8d\x93\xbfK#A\x14\x80\xbf\
\xbd\x8d\xa40\x1c!`\x11\x0e\x0c\x01\x11\x7f \xd7(\x87"B\xba\xdc?\x92*\xf7o\
\x84E\xc9\x1f\xb0`\x8a\xa4\x11\xc1\xe2*\xdd\xa0\\ac\x99\xc2b\xa3\x85\x07Wy\
\xe7Y\xc99\xbb\x99\xdd\x99+\xe2\xc6\r\xeen|\xcd\xbcy\xbc\xf7\xcd|\x03c\x14\
\x8bE\xe2Q\xaf\xd753\xc2q\x1c#\xcasI\r\xadV\xebM\xed\xee\xe6\x9a\xc3\xee\x11\
\xb5Z\r@G\x90D\x00@\xb5Z\x9d\xda\x17\n\x05\x16N/h4\x1aQI;\x8ec\xa4\x02\xda\
\xed6;[kl\xef}\x05\xa0T*a\x9a&\x83\xc1`\x02\x19\x0e\x87:\x15\x10\x1f\x060M\
\x93r\xb9L\xaf\xd7\xa3\xd3\xe9\xe0\xba.\x99\n\xf1\xe1(\xbe5\x9b\xfc}\xf8\xcd\
\xad{\xcd\xd2b\x99\xee\xd1\t\x1f\xb2\x14\xae.\xcf\xa6\xf2\xb9\x9cA\xa9\xf8\
\x91\xf5\xd5\x15>o\xac\x03$\x03\x0c\xc3\x98R\x88\xf2P\nt(\xc8\xe7M\x94w\x9f\
\xae\xa0\xb5\x9e\x0ck\xad\xd8\xfc\xb2\x87\xff\xef\x91P\xfa\xa0|\x94\xf4&\xbd\
3\x15\x82\x91@IA8\xf2PR`w\xbfs\xfb\xf3\x17\x84~6 \xba\xb6\x92\x82Pz\xa8@\xa0\
F\xcf\xafj\xe1(]\x01`sk\x17\xff\xe9\x810\xf0\xc6\x80\x17\xc8\xf2\xa7y\xfe\
\xb8\xe7\xa0d:\xc0\xb6\xed\xd8\x83\x08\xd0\x1e\xe0\x8d\xd7x\x9e\xa5\x00`Y\
\x16\x10`\xed\xdb\xa0\x03\xac\x83c \x00\x1d\x8cW\xc0H\xfa\x8d\x95J\xe5\x1d\
\xa7K\xfa?D\xb2B\xbf\xdf\xcf\xba\xd8T\xfc\x07\xf21\xbe\xfd\n\xd2\xaa\xc8\x00\
\x00\x00\x00IEND\xaeB`\x82Y\xfe\xcd\xa3' )

def getcppBitmap():
    return wxBitmapFromImage(getcppImage())

def getcppImage():
    stream = cStringIO.StringIO(getcppData())
    return wxImageFromStream(stream)

def getcppIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getcppBitmap())
    return icon

#----------------------------------------------------------------------
def gethData():
    return zlib.decompress(
'x\xda\x01\xd0\x01/\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\x87IDATx\x9c\x85\x93\xbfk\xdb@\x14\x80?U)\
\x19j\x821t0\x85\x80!\x94&\xa6t\x91)-\xc5\xe0\xcd\xf9G<%k\x97\xd2\x8e\xde<\
\x84L\x85x\xb01x)\xa6S+h\xa7.\x1d=x\x90\x93!\x81Nm\x9cv1\xd6\xaf\xd3\xddeH\
\xa5\xd8X\x92\x1f\x1c\xf7\xeeq\xef\xbb\xf7\rg\x14\x8bE\x96\xa3\xd9lj6\x84m\
\xdbF\x9co\xa5]h\xb7\xdbk\xb5\xcb\xf3\tg\xbd!\x8dF\x03@\xc7\x90T\x00@\xa5RY9\
\x17\n\x05\x1e\x7f\xf9N\xab\xd5\x8aK\xda\xb6m#\x13\xd0\xe9tx];\xe0U\xfd\x10\
\x80R\xa9\x84i\x9a\x8c\xc7\xe3\x042\x9dNu&`\xb9\x19\xc04M\xca\xe52\xfd~\x9fn\
\xb7\x8b\xe38\xe4*,7\xc7q|t\xc4\xcd\xec\x0f\x17\xce\x84\xbd\xdd2\xbd\xe1\'\
\x1e\xe4)\xfc\xfc\xf1u%\x7f\xb8eP*\xeeP\xdd\x7f\xc6\x8b\xe7U\x80t\x80a\x18+\
\nq.\x85\x87\x96\x1e\xdb\xdb&\xca\xff\x9d\xad\xa0\xb5N\x9a\xb5VX/\xeb\x04\
\x8b\xbfH\x11\x80\nP\xc2O\xeenT\x88B\x0f%<d\xe8\xa3\x84\xc7\xc7\xdeg.\xae~\
\x81\x0c\xf2\x01\xf1\xd8JxH\xe1\xa3"\x0f\x15\xba\xf7j2\xccV\x00\xb0jo\x08\
\xe63d\xe4\xdf\x01\xfeC\x9e>y\xc4\xb5\xf3\r\x94\xc8\x06\x8cF\xa3$\x97\xee\
\x02\xe9.P\xae\xbb\xb6\xe7*\x00(\x11\xf2\xf6\xfd\x07\xb4\x10\xbc;9E\x0b\x91,\
\x15\xddM`\xa4\xfdF\xcb\xb26\xbe\xae"\x81\xfdo\x9e\xae0\x18\x0c\xf2\x06[\x89\
[4T\xdb|\xaf\x1b\x15\x1a\x00\x00\x00\x00IEND\xaeB`\x82\xca\x9f\xc9\xae' )

def gethBitmap():
    return wxBitmapFromImage(gethImage())

def gethImage():
    stream = cStringIO.StringIO(gethData())
    return wxImageFromStream(stream)

def gethIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(gethBitmap())
    return icon

#----------------------------------------------------------------------
def getlData():
    return zlib.decompress(
'x\xda\x01\xd1\x01.\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\x88IDATx\x9c\x85\x93=k\x1bA\x10\x86\x9f\
\xcb)\xb8\xb0\x08B\x90B\x04,\x04\xc1\xc4\x11\xc1\x8dDH0\x06u\xf2\x1fQ\xe5\
\xfc\r\x91F\x85\xdd\x1dX\x85\x04AM\x8aT\xce\x89\xa4J\x93R\x85\x8a\x93]\xd8\
\xe0\xca\x9f\x95\x88\xf6nW\xb7\xebB:IG\xee\xa4i\xe6\xdda\xe6\xd9y\x17\xd6\
\xca\xe5r\xacF\xbd^7l\x08\xd7u\xadHg\x92\x1a\x9a\xcd\xe6\x7f\xb5\xab\x8b!g\
\x9d\x1e\xb5Z\r\xc0D\x90D\x00@\xa9T\x8a\x9d\xb3\xd9,\xaf\xcf\x7f\xd3h4\xa2\
\x92q]\xd7J\x05\xb4Z->W\xdf\xf3\xe9\xf0\x08\x80|>\x8fm\xdb\x0c\x06\x83\x05d4\
\x1a\x99T\xc0\xea0\x80m\xdb\x14\n\x05\xba\xdd.\xedv\x1b\xcf\xf3Xkau8\x8a/\
\xc7\xc7<>\xdcq\xe9\ry\xbbS\xa0\xd3\xfb\xce\x8bu\x16\xfe\xfe\xf9\x19\xd3/3\
\x16\xf9\xdc+\xca{\xef\xd8\xffP\x06H\x06X\x96\x15\xb3\x10\xe9P\tL(\xd8\xda\
\xb2\xd1\xfem\xba\x05c\xccb\xd8\x18M\xe5\xe3!\xc1\xbf\'B\x15\x80\x0e\xd0\xca\
_\xf4n\xb40\x95\x02\xad\x04\xa1\xf4\xd1J\xe0t~py}\x03a\xb0\x1e\x10\xad\xad\
\x95 T>z*\xd0r\xb2\xb4\x16\xcat\x0b\x00\x95\xea\x01\xc1\xf8\x81p\xea\xcf\x00\
s\xc8\xee\x9bm\xee\xbd_\xa0U:\xc0q\x9c\x85\x9e\x08\x10\x02&~<\x07r\xc3\x1b\
\x00H\t\xa7\'_\x91\n\xbeugY)\x90j\xd9c%\xfd\xc6b\xb1\x88\xd6\xf3\xdb\xfde\
\x8e6Ps@0\xee\'[\xe8\xf7\xfb\xeb\x16\x8b\xc53\x9f\x96\xc5\x1bS\xb5\xc1\xbe\
\x00\x00\x00\x00IEND\xaeB`\x82]\x10\xceJ' )

def getlBitmap():
    return wxBitmapFromImage(getlImage())

def getlImage():
    stream = cStringIO.StringIO(getlData())
    return wxImageFromStream(stream)

def getlIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getlBitmap())
    return icon

#----------------------------------------------------------------------
def getoData():
    return zlib.decompress(
'x\xda\x01\xbf\x01@\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01vIDATx\x9c\x85\x93=K\x03A\x10@\xdfyJ\n\x83\
\x84\x80E\x10\x0c\x01\x11?\x10\x1b\x83("\xa4\x8b\x7f$\x95\xfe\x8d`\x13\xb4\r\
\x1a!il,\xac\xf4\x82V6\x96)R\\\xb4P\xb0\x8aFmD\xefsw-\xf4b\x82w\x97Y\x16f\
\x87\x9d\xb7\xf3\x8a\xd5R\xa9\x14\x83Q,\x16\x15#\xc20\x0c-\xc8\xc7\xc3.\x94\
\xcb\xe5\x7f\xb5\x87\xbb6\xc7\xf5S\n\x85\x02\x80\n \xa1\x00\x80\\.7tN&\x93L_\
\\S*\x95\x82\x922\x0cC\x8b\x04T*\x156\xf3Kll\xef\x00\x90N\xa7\xd1u\x9dV\xab\
\xd5\x87t:\x1d\x15\t\x18l\x06\xd0u\x9dL&C\xa3\xd1\xa0V\xaba\x9a&\xb1\n\x83\
\xcdA\xec\xed\xee\xf2\xda{\xe6\xdel37\x9b\xa1~z\xc6X\x9c\xc2\xed\xcd\xe5P>1\
\xae\x91NM\xb1\xbc\xb8\xc0\xea\xca2@8@\xd3\xb4!\x85 \x17\x9e\x85\x12\x16\x89\
\x84\x8e\xb4\xbb\xd1\nJ\xa9~\xb3R\x92\xb5\xf5m\x9c\xcf7\x84\xe7\x80t\x90\x9e\
\xdd\xbf;R\xc1w-\xa4g!\\\x1b\xe9YT\xeb\xe7\xdc?>\x81p\xe2\x01\xc1\xd8\xd2\
\xb3\x10\x9e\x8d\xf4-\xa4\xfb\xf5\xa7&\xdch\x05\x80\xb5\xfc\x16\xceG\x0f\xe1\
\xdb?\x80_\xc8\xfc\xcc$/\xe6\x15H/\x1aP\xadV\xfb\xb9\x83\x8d\x8b\x13\xbac\
\x15\x00||\x0e\xf6\x0f\x11\x08\x8e\xf6O\x10\x03\xcbG\x00\xa0\x85\xfd\xc6l6;\
\xf2u\x1fA\xb7\xf9\x1e\xae\xd0l6\xe3\x06\x1b\x8aow\xf5\xc76\xba\xa5c\x86\x00\
\x00\x00\x00IEND\xaeB`\x82A\x8c\xbbm' )

def getoBitmap():
    return wxBitmapFromImage(getoImage())

def getoImage():
    stream = cStringIO.StringIO(getoData())
    return wxImageFromStream(stream)

def getoIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getoBitmap())
    return icon

#----------------------------------------------------------------------
def getyData():
    return zlib.decompress(
'x\xda\x01\xd0\x01/\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\x87IDATx\x9c\x85\x93\xbfk\xdb@\x14\x80?U)\
\x19j\x821t0\x85\x80!\x94&\xa6t\x91)-\xc5\xe0\xcd\xf9G<%k\x97\xd2\x8e\xde<\
\x84L\x85x\xb01x)\xa6S+h\xa7.\x1d=x\x90\x93!\x81Nm\x9cv1\xd6\xaf\xd3\xddeH\
\xa5\xd8X\x92\x1f\x1c\xf7\xeeq\xef\xbb\xf7\rg\x14\x8bE\x96\xa3\xd9lj6\x84m\
\xdbF\x9co\xa5]h\xb7\xdbk\xb5\xcb\xf3\tg\xbd!\x8dF\x03@\xc7\x90T\x00@\xa5RY9\
\x17\n\x05\x1e\x7f\xf9N\xab\xd5\x8aK\xda\xb6m#\x13\xd0\xe9tx];\xe0U\xfd\x10\
\x80R\xa9\x84i\x9a\x8c\xc7\xe3\x042\x9dNu&`\xb9\x19\xc04M\xca\xe52\xfd~\x9fn\
\xb7\x8b\xe38\xe4*,7\xc7q|t\xc4\xcd\xec\x0f\x17\xce\x84\xbd\xdd2\xbd\xe1\'\
\x1e\xe4)\xfc\xfc\xf1u%\x7f\xb8eP*\xeeP\xdd\x7f\xc6\x8b\xe7U\x80t\x80a\x18+\
\nq.\x85\x87\x96\x1e\xdb\xdb&\xca\xff\x9d\xad\xa0\xb5N\x9a\xb5VX/\xeb\x04\
\x8b\xbfH\x11\x80\nP\xc2O\xeenT\x88B\x0f%<d\xe8\xa3\x84\xc7\xc7\xdeg.\xae~\
\x81\x0c\xf2\x01\xf1\xd8JxH\xe1\xa3"\x0f\x15\xba\xf7j2\xccV\x00\xb0jo\x08\
\xe63d\xe4\xdf\x01\xfeC\x9e>y\xc4\xb5\xf3\r\x94\xc8\x06\x8cF\xa3$\x97\xee\
\x02\xe9.P\xae\xbb\xb6\xe7*\x00(\x11\xf2\xf6\xfd\x07\xb4\x10\xbc;9E\x0b\x91,\
\x15\xddM`\xa4\xfdF\xcb\xb26\xbe\xae"\x81\xfdo\x9e\xae0\x18\x0c\xf2\x06[\x89\
[4T\xdb|\xaf\x1b\x15\x1a\x00\x00\x00\x00IEND\xaeB`\x82\xca\x9f\xc9\xae' )

def getyBitmap():
    return wxBitmapFromImage(getyImage())

def getyImage():
    stream = cStringIO.StringIO(getyData())
    return wxImageFromStream(stream)

def getyIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getyBitmap())
    return icon

#----------------------------------------------------------------------
def getcData():
    return zlib.decompress(
'x\xda\x01\xd1\x01.\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\x88IDATx\x9c\x85\x93=k\x1bA\x10\x86\x9f\
\xcb)\xb8\xb0\x08B\x90B\x04,\x04\xc1\xc4\x11\xc1\x8dDH0\x06u\xf2\x1fQ\xe5\
\xfc\r\x91F\x85\xdd\x1dX\x85\x04AM\x8aT\xce\x89\xa4J\x93R\x85\x8a\x93]\xd8\
\xe0\xca\x9f\x95\x88\xf6nW\xb7\xebB:IG\xee\xa4i\xe6\xdda\xe6\xd9y\x17\xd6\
\xca\xe5r\xacF\xbd^7l\x08\xd7u\xadHg\x92\x1a\x9a\xcd\xe6\x7f\xb5\xab\x8b!g\
\x9d\x1e\xb5Z\r\xc0D\x90D\x00@\xa9T\x8a\x9d\xb3\xd9,\xaf\xcf\x7f\xd3h4\xa2\
\x92q]\xd7J\x05\xb4Z->W\xdf\xf3\xe9\xf0\x08\x80|>\x8fm\xdb\x0c\x06\x83\x05d4\
\x1a\x99T\xc0\xea0\x80m\xdb\x14\n\x05\xba\xdd.\xedv\x1b\xcf\xf3Xkau8\x8a/\
\xc7\xc7<>\xdcq\xe9\ry\xbbS\xa0\xd3\xfb\xce\x8bu\x16\xfe\xfe\xf9\x19\xd3/3\
\x16\xf9\xdc+\xca{\xef\xd8\xffP\x06H\x06X\x96\x15\xb3\x10\xe9P\tL(\xd8\xda\
\xb2\xd1\xfem\xba\x05c\xccb\xd8\x18M\xe5\xe3!\xc1\xbf\'B\x15\x80\x0e\xd0\xca\
_\xf4n\xb40\x95\x02\xad\x04\xa1\xf4\xd1J\xe0t~py}\x03a\xb0\x1e\x10\xad\xad\
\x95 T>z*\xd0r\xb2\xb4\x16\xcat\x0b\x00\x95\xea\x01\xc1\xf8\x81p\xea\xcf\x00\
s\xc8\xee\x9bm\xee\xbd_\xa0U:\xc0q\x9c\x85\x9e\x08\x10\x02&~<\x07r\xc3\x1b\
\x00H\t\xa7\'_\x91\n\xbeugY)\x90j\xd9c%\xfd\xc6b\xb1\x88\xd6\xf3\xdb\xfde\
\x8e6Ps@0\xee\'[\xe8\xf7\xfb\xeb\x16\x8b\xc53\x9f\x96\xc5\x1bS\xb5\xc1\xbe\
\x00\x00\x00\x00IEND\xaeB`\x82]\x10\xceJ' )

def getcBitmap():
    return wxBitmapFromImage(getcImage())

def getcImage():
    stream = cStringIO.StringIO(getcData())
    return wxImageFromStream(stream)

def getcIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getcBitmap())
    return icon

#----------------------------------------------------------------------
def getfData():
    return zlib.decompress(
'x\xda\x01\xbf\x01@\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01vIDATx\x9c\x85\x93=K\x03A\x10@\xdfyJ\n\x83\
\x84\x80E\x10\x0c\x01\x11?\x10\x1b\x83("\xa4\x8b\x7f$\x95\xfe\x8d`\x13\xb4\r\
\x1a!il,\xac\xf4\x82V6\x96)R\\\xb4P\xb0\x8aFmD\xefsw-\xf4b\x82w\x97Y\x16f\
\x87\x9d\xb7\xf3\x8a\xd5R\xa9\x14\x83Q,\x16\x15#\xc20\x0c-\xc8\xc7\xc3.\x94\
\xcb\xe5\x7f\xb5\x87\xbb6\xc7\xf5S\n\x85\x02\x80\n \xa1\x00\x80\\.7tN&\x93L_\
\\S*\x95\x82\x922\x0cC\x8b\x04T*\x156\xf3Kll\xef\x00\x90N\xa7\xd1u\x9dV\xab\
\xd5\x87t:\x1d\x15\t\x18l\x06\xd0u\x9dL&C\xa3\xd1\xa0V\xaba\x9a&\xb1\n\x83\
\xcdA\xec\xed\xee\xf2\xda{\xe6\xdel37\x9b\xa1~z\xc6X\x9c\xc2\xed\xcd\xe5P>1\
\xae\x91NM\xb1\xbc\xb8\xc0\xea\xca2@8@\xd3\xb4!\x85 \x17\x9e\x85\x12\x16\x89\
\x84\x8e\xb4\xbb\xd1\nJ\xa9~\xb3R\x92\xb5\xf5m\x9c\xcf7\x84\xe7\x80t\x90\x9e\
\xdd\xbf;R\xc1w-\xa4g!\\\x1b\xe9YT\xeb\xe7\xdc?>\x81p\xe2\x01\xc1\xd8\xd2\
\xb3\x10\x9e\x8d\xf4-\xa4\xfb\xf5\xa7&\xdch\x05\x80\xb5\xfc\x16\xceG\x0f\xe1\
\xdb?\x80_\xc8\xfc\xcc$/\xe6\x15H/\x1aP\xadV\xfb\xb9\x83\x8d\x8b\x13\xbac\
\x15\x00||\x0e\xf6\x0f\x11\x08\x8e\xf6O\x10\x03\xcbG\x00\xa0\x85\xfd\xc6l6;\
\xf2u\x1fA\xb7\xf9\x1e\xae\xd0l6\xe3\x06\x1b\x8aow\xf5\xc76\xba\xa5c\x86\x00\
\x00\x00\x00IEND\xaeB`\x82A\x8c\xbbm' )

def getfBitmap():
    return wxBitmapFromImage(getfImage())

def getfImage():
    stream = cStringIO.StringIO(getfData())
    return wxImageFromStream(stream)

def getfIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getfBitmap())
    return icon

#----------------------------------------------------------------------
def getjavaData():
    return zlib.decompress(
'x\xda\x01\xc4\x02;\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02{IDATx\x9c\x8d\x92\xdfKSq\x18\xc6?g[\xee\
\x87[\xae\x93s\x0e%\xd2\xb9\xb9&\xb6\x94\xca\xa0\x0c\xf5"\x8c\x10\x82\xc0\
\x8b\x10\xebJ\xd0\x9b\xee\xfb\x03\xfc+\xf2\xc2ay\xa3\xdd\x14\xb5\xa4\x02\x19\
\x12\x84a\xe8\x85\x8a\xba$\xb71\xad\xa6;\xea~\x9f\xf3\xedBfYF>W\xef\xfb\xf0\
\xf2\xe1\xe5\xe1\x91\xecv;\xbf\xab\xbb\xbb[\xf0\x1f\x85B!\xa94\x1b\x8e;\x18\
\x1e\x1e\xfe\xcb\x8b,/\xf0dt\x9c\xce\xceN\x00Q\x82\x1c\x0b\x00\xa8\xab\xab;\
\xb2[\xadV\x1c\xaf\xde200P\xb2D(\x14\x92\xfe\t\xf8S\xb2,\xa3\xd7\xeb\x99\x9b\
\x9b;\x84,--\x89\x13\x03\xf4z=.\x97\x8b`0\xc8\xc8\xc8\x08\x8b\x8b\x8b\x00H\
\xa5\x10/\xb6\xb6\x8a\x8e\xeb\xd7\xf0z\x1a\xb0\x18\xf2\xd8lvT\xc0\xd7\xdc\
\x86\xa6\t\x14E\xc1l6\xe3t:\x99\xfd0\xcd\xc2\xfc\x02\xa3\xe3\x13\xe8M&\x13==\
wD\xff\xdd.lf\x15#96\xd6VPU\x95\xc4\x97\x08\x1f\xdf\x87X\x9e\xff\x84\xed\xac\
\x93\x89\xc9\xe7\xf8\x1b\xeb\xa9\xa9v\xa2\xd7I\xbcy7\x8d\xc1.\xcb\xa2\xc9]Kx\
j\x92\xc6\xc0e\xd6\xa2Q\xd2\xbb\n\xdf\xbfna\xaf\x94\xd9K&I\xfdXE\xc9\xa9\xd4\
\xbb}$\xe2\x1b\xf8}\x1e\xb4l\x02\x00\xc3N2)-\xaeo\x8a\xb6\x96\x1b\xcc\x86_\
\x80\xd0(d\x04\x920\xb2\x19\xb5\x90\xdf\xdfG\xf6\xf9\x89&\x15\x02WNc<%\xa1\
\x15\xb2\xbf\xb2io\xbf)\x1e<\xecg7\xafq\xb5\xeb\x1ef\xab\x03\x8b\xec\xc0h\
\xab%g2\x11\xd7\x8cL\xbe|\x8d\x10*-\x81&\xbc\xf55\x98\xcb \x11[g*\xfc\x19C\
\xa3\xd7G\xeb\xa5\x16\x0c:\x89\x95\xd5U\x94\xb4J"\x05\x91\xc8:\xb1x\x94o[[x\
\x1a\x1ap\xbb\x1b\x88\xc5\xe2d\xf6\xces\xc6\xa2\x035\x0f\x80n\xeciP\n\xcf\
\xcc\xe0\xf5\xfap8\xaa\xd8\xdeVP\x94\x14\xc5b\x11\xb3\xa9\x1c\x8f\xa7\x1e\
\xbf\xbf\x99\xea*\x07\xe7\\2\xe9\xb4\x82Z\xc8\x82V8\xc8\x00`hpP\xba\xdf\xd7\
\'.\xf8|\x04\x02\xcd$wv\xd9S\x92\xa4\xd3\x19\xb2\xd9\x1c\x15V\x03\xee\xdaJ\
\xaad+\xb2\xcd\x84VH\x1f~pX\xa4gcc\x12@oo\xaf\xb8}\xab\x034;B\xcd\x83\x96\
\xc7\\f\xa0\xc2ZF\xa5\xddJ\xb9Q\x87V\xc8\x80\x96;\n(IQ\x14\x9c\x8e\x83ri\xc5\
4\xa2\x90A\x142\xe4\xb3)b\x1b\x89\xc3\x1dM=\x1e\x000\xf4\xe8\xf1I\x1b\xceO\
\xfb\xd8\x06\xf36\xf9r|\x00\x00\x00\x00IEND\xaeB`\x82\xb3\xd6C\x8c' )

def getjavaBitmap():
    return wxBitmapFromImage(getjavaImage())

def getjavaImage():
    stream = cStringIO.StringIO(getjavaData())
    return wxImageFromStream(stream)

def getjavaIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getjavaBitmap())
    return icon

#----------------------------------------------------------------------
def getmocData():
    return zlib.decompress(
'x\xda\x01\t\x02\xf6\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\xc0IDATx\x9c}\x93\xbf\x8e\xda@\x10\xc6\
\x7f\x8e\xf2\x00Ngt\x14\x96\xb6qIA\t:\xe7\rR\x1a\t\x89&\xdd5<@N\xd8o\xe0&\
\xd2\x15\x14Ggw\x94\xe9X_(#A\xb9EV\xda\xc2\x12\xee\x8e\x17@\xbe\xc2\xc6\xc6@\
2\xd2J\xf3g\xe7\x9b\x99O3\x96m\xdb\\J\x1c\xc7\xe5\xa5m\x8cit)C\xf6{\xdb\xba\
\x8c\x7f\xe6\x8e\xccf\xb3{n\\\xd7\xc5\x18S\xc6q\xdc\x80|\xba\xfb\xf3?2\x9dN\
\x99\xcf\xe7M\x97\xff\x04\xc8\xb2\xea\xadV\xab\xc6\'\x84\x00`\xb1X4 w\x01\
\xb2\xac\xd5\x8d\x99\x11E\xad\xbd\xddn\x99L&(\xa5p]\xb7\xb4\xee\x91h\xcc\x8c\
\x90\x88\x90\x05!\x11HI\xb9\xd94\x7f\xb4\xd6\x1c\x0e\x07\x9e\x9f\xc7\xb7$\
\x8eF#\xce\xc4+5\x81\xa2\xe8\xc4\xb5\xd6\x00\xf4z=\x1c\'h\x01\xde\xd7\xeb\
\x8a\x98<G\xa9\x1f\x04@rN\x96mu!\x04\xe8\x14\xcd\x90\x0e\x07\xd9\x8b\x0f\xd2\
\x87\xe2\xa5\xae\xae\x08\x1c\x07\x80 \x98\x10E\x16\xe8\xb4\xea\xa2N\x86\xab=\
(\xc3\x9272<$O\xbf\x9f\x18\x9fN\xc8G\xf03\x1f$L\x19"t\x8a\xb8\xc8\xe9\x00\
\xbc\x05\x162\xa9\xf4\xf1)\x04\xc0\x8f P\x01I\x91 \x16\x82\x9a\x82Z\xd6-\xc0\
\xb7_\xb6\xf5~<\x96\x00\xf3\xc1\x00\xd8\x13J\x08\xaf\x08\x14\xfc\x81\xdc\x81\
~\xd1\xe5\x00\xe0\x8bm[\xe6\xf5\x95\xddn\x07\xb4\xc9I\x91\xb4 \x0c\xd1\xfd>\
\xdb\xc3\xc3\xed\x08P\x1f\x8fN)\x1fK\xe8\xa7|\xfd\x1e\xb0Y&h\x86Uu\x80\xdcA\
\xf4\x0b~^w\x00\xd5\xc1\x9cY\xd6\x0cY.\xff6\xb1\xed\xe1\x01r\x87\x0c\xbf\x1a\
\x03\xb8\xd9\xc4\xc1\xe0X\xfa~\xd8\xf1)\xa5\xf0\xbc\x04\xa5\x02<\xcf\xabm\
\x0f)C>\x00 \\\xb9\x02\x0f\x16E\xac\x00\x00\x00\x00IEND\xaeB`\x82\xb7.\xe3?'\
 )

def getmocBitmap():
    return wxBitmapFromImage(getmocImage())

def getmocImage():
    stream = cStringIO.StringIO(getmocData())
    return wxImageFromStream(stream)

def getmocIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getmocBitmap())
    return icon

#----------------------------------------------------------------------
def getplData():
    return zlib.decompress(
'x\xda\x01\xe0\x01\x1f\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\
\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\
\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\x97IDATx\x9c\x85\x91OK\x1bQ\x14G\xcf8\
\x8a\x8b\x06\t\x01\x17A(\x04\xa4\xf8\x87\xe2F\x91\x16\x11\xb2K\xbfH\x16b\xe9\
\xde\x0f\x90]6.\x04\xc5@\x93.\xdcT\x08]\xb4\x03\x15i\x0b\xa5\x8b\x96f!tR\xc1\
\x16\xd4\x85\x1a]\x89\xbe\x99y\xf3\xdes\xa13I0\x93\xdc\xd5}\x97{\x0f\xbf\xc3\
\xb3\xd2\xe94\x9dU(\x14\x0c\x03\xcaq\x1c+\xea\x87{-\x94J\xa5G\xb3\x7f\x7f\
\x0f\xd8\xae\xee\x90\xcf\xe7\x01L\x04\xe9\t\x00\xc8\xe5r]\xefT*\xc5\xf8\xc7=\
\x8a\xc5b42\x8e\xe3X\x89\x80r\xb9\xcc\xcb\x85\x19^,\xbf\x02 \x93\xc9`\xdb6\
\x8dF#\x864\x9bM\x93\x08\xe8<\x06\xb0m\x9bl6K\xadV\xa3R\xa9\xe0\xba.}\x15:\
\x8f\xa3z\xbd\xba\xcae\xeb\x9cC\xf7\x80\xc9\xa7Y\xaa;\xef\x19\xea\xa7\xf0\
\xe3\xdb\xa7\xae~d\xd8"\x93\x1ecvz\x8a\xb9\xe7\xb3\x00\xbd\x01\x96eu)D\xbd\
\x92\x02\xa3\x04\xa3\xa36\xda;KV0\xc6\xc4\xc7\xc6h\xe6\x17\x97\xf1o\xaeP\xd2\
\x07\xed\xa3\xa5\x17\xef\x0eT\x08\x03\x81\x96\x02\x15xh)\xd8\xac\xd69\xfc\
\x7f\x0c\xca\xef\x0f\x88bk)P\xd2C\x87\x02\x1d\xdc\xb6\xd5T\x90\xac\x000\xbf\
\xb0\x84\x7f\xddB\x85\xde=\xe0\x01\xf2l\xe2\t\x17\xeeg\xd0\xb2\x7f\x82\xf5\
\x8d-~7~\xa1\x02\xc1\xd6\xbb\x0f\xfc9:E\x07\x82\xb7\xf5\x9f\x1c\xb5\xc28\xc1\
`\x85P\xb4\x7f!\xf4\xda\n\xdaOV8;i\x02\xf0}\x7f\x17#\x05F\n\xbe\xd6\xd7\xe3~\
\xbf\xfa\x05\xb4J\x06\xac\xbcYK\n\xf6\xa8\xee\x00qf\xcb\x1dX=\xaf\xfa\x00\
\x00\x00\x00IEND\xaeB`\x82t2\xcf\xef' )

def getplBitmap():
    return wxBitmapFromImage(getplImage())

def getplImage():
    stream = cStringIO.StringIO(getplData())
    return wxImageFromStream(stream)

def getplIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getplBitmap())
    return icon

#----------------------------------------------------------------------
def getsData():
    return zlib.decompress(
'x\xda\x01\xd1\x01.\xfe\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x01\x88IDATx\x9c\x85\x93=k\x1bA\x10\x86\x9f\
\xcb)\xb8\xb0\x08B\x90B\x04,\x04\xc1\xc4\x11\xc1\x8dDH0\x06u\xf2\x1fQ\xe5\
\xfc\r\x91F\x85\xdd\x1dX\x85\x04AM\x8aT\xce\x89\xa4J\x93R\x85\x8a\x93]\xd8\
\xe0\xca\x9f\x95\x88\xf6nW\xb7\xebB:IG\xee\xa4i\xe6\xdda\xe6\xd9y\x17\xd6\
\xca\xe5r\xacF\xbd^7l\x08\xd7u\xadHg\x92\x1a\x9a\xcd\xe6\x7f\xb5\xab\x8b!g\
\x9d\x1e\xb5Z\r\xc0D\x90D\x00@\xa9T\x8a\x9d\xb3\xd9,\xaf\xcf\x7f\xd3h4\xa2\
\x92q]\xd7J\x05\xb4Z->W\xdf\xf3\xe9\xf0\x08\x80|>\x8fm\xdb\x0c\x06\x83\x05d4\
\x1a\x99T\xc0\xea0\x80m\xdb\x14\n\x05\xba\xdd.\xedv\x1b\xcf\xf3Xkau8\x8a/\
\xc7\xc7<>\xdcq\xe9\ry\xbbS\xa0\xd3\xfb\xce\x8bu\x16\xfe\xfe\xf9\x19\xd3/3\
\x16\xf9\xdc+\xca{\xef\xd8\xffP\x06H\x06X\x96\x15\xb3\x10\xe9P\tL(\xd8\xda\
\xb2\xd1\xfem\xba\x05c\xccb\xd8\x18M\xe5\xe3!\xc1\xbf\'B\x15\x80\x0e\xd0\xca\
_\xf4n\xb40\x95\x02\xad\x04\xa1\xf4\xd1J\xe0t~py}\x03a\xb0\x1e\x10\xad\xad\
\x95 T>z*\xd0r\xb2\xb4\x16\xcat\x0b\x00\x95\xea\x01\xc1\xf8\x81p\xea\xcf\x00\
s\xc8\xee\x9bm\xee\xbd_\xa0U:\xc0q\x9c\x85\x9e\x08\x10\x02&~<\x07r\xc3\x1b\
\x00H\t\xa7\'_\x91\n\xbeugY)\x90j\xd9c%\xfd\xc6b\xb1\x88\xd6\xf3\xdb\xfde\
\x8e6Ps@0\xee\'[\xe8\xf7\xfb\xeb\x16\x8b\xc53\x9f\x96\xc5\x1bS\xb5\xc1\xbe\
\x00\x00\x00\x00IEND\xaeB`\x82]\x10\xceJ' )

def getsBitmap():
    return wxBitmapFromImage(getsImage())

def getsImage():
    stream = cStringIO.StringIO(getsData())
    return wxImageFromStream(stream)

def getsIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getsBitmap())
    return icon

#----------------------------------------------------------------------
def gethtmlData():
    return zlib.decompress(
'x\xda\x01\xf3\x02\x0c\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\
\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\
\x08\x08\x08\x08|\x08d\x88\x00\x00\x02\xaaIDATx\x9c\x85\x92_h\x8dq\x18\xc7?\
\xef9;;\xef\xd99;{\xf7f\xb3e\xcc\x98\x8dvXF.\xa4\xb1&\xa6\xe4\x02\xb9`-.\xac\
(&n\xb9\xa0L\x96+%\x91\x92$%D\x8a\x93\\HJ$#cg\x7fhg\xc6kl\xef\xe8\xccy\xdfs~\
\xe7}\x7f.\xe6`9\xe5{\xf5<\xdf\x9e\xe7\xd3\xd3\xb7G\xd14\x8d\xbf\xd5\xd2\xd2\
"\xf9\x8f\xa2\xd1\xa8\x92\xad\xf3r\rtvv\xfe\xe3\xbd\xef{\xcd\x85KWijj\x02\
\x90YHN\x00@UU\xd5\xb4>\x14\nQr\xf7\x01\xed\xed\xedYKF\xa3Q\xe5\x1f@\xbc\xa0\
\x99\xc6\x9d\'\xa8\xad\t\xb1!2\x87C\x1d\x07\x00\xd0u\x1d\xaf\xd7Kww\xf7oH,\
\x16\x93J6\x83\xda\xb6sr\xa3z\x96\x8e\xd6\xa5\\\x1f\xac\xe6v\xac\x81/\x83=|\
\x18|\xc6\xc5c;Y\xbbz%]]]\x18\x86\x81\x10\x82\xde\xde^L\xd3\xc4\xab\xaa*\xb5\
m\xe7\xe4\xd1\x1dE\xecjj\xc6.\\D\xc8\x1e\xa0\xb2\xf0\x11\xb6m3\x9c\x88p\xe5\
\xf2i\x96\xd6\xccf\xeb\x96\xcd\xd4/\x89P\xaa\x17\xa2\x15\x06y\xd5\xf3\x16\
\x0f\x809\xdcG}Y\x18\xa5\xa4\x0e\xd7\xfeBqX\xa0\x8e~%n\xcdG-\xd0)\xd0"\\\xbb\
\xf7\x18\xc3\xf8\x88\xae\x85\xa9[\xb4\x90\xfa\xc5u\x00xJ\xd6\x1c\x94\x0b\x96\
\xafBf| \x04\x81\xc4\x00\xf6\x98\xc9\x99\xf7\xdb\x98\xf44\xe0\xf3\xe7\xe3\
\xc9/\xe2\xd6\xfdG\x18#q\xa4c\xe1\xf7{q\xed\xcfS\x00e\xf4\x1d+j+8yg\x88\x84q\
\x8b\xe3\xcffp\xe3\xd3:\xf2JW\x90\xe7\xf5\x90q\x1c\x1cW\x02\x92o\xdf\xc6\xc1\
M\xe1\n\xfbw\xe8\x9e\x8cL\xf3r`\x1c\x7fy\x03G\x1e\xce\xa7\xad\xf2\r\xdd\xc3\
\x01\x9c\xf1\'\xfc\xf8>J\xf2{\x12\x92\xfd\x00\xb8\xe2\xd7\xb2\x93\x04\'5\xf5\
Hf\xec\x9e\xd2?w\x99T\x03-\x04\x8b\xe7\xd1\xd1\xb3\x9bS\xcb\xce\xd3\x13\x1f\
\xe4\xe6\xc3\x02F\xc64|\xc9\xcf\xaconD\x88\x14N:\t\x19\x1b\x9c\xf4\x9fO\x1c\
\x7f\x15\xe5cE\x19>\xa3\x0c+\xa3\xd1\xa7>\xa5\x7f(\x80\x1f\x83\xc0d\x10\x93|\
\xca\xc3IB\xaa\x077c\xe1\x88\x14\xb8\xe2\x0f e<WbQW\x06\x8a\xe7\xa1U\xd6pz\
\xa8\x125\x19g"\r\xa6\xc8g\xcf\xa6\xe5,\xae\x9e\xc5L=\x8c\x93\xb6q\x855\xfd\
\x02\x001\xf2B\x11#/\xb0&\x1a\xa4\x01@\x90\xf5K\xca\xd9\xb7\xbd\x91\x90\xea\
\xa3\xa2LG/\n\xe0\nk\n\xe0\xa6\xa6\x03\xb2j\x8e\x94\xb2ww+\x13\x13&^7E8\xe8\
\xc3\xeb\n&\x13c$\xcc\x0fHa!\x85\x05\xae\x93\x1b\x00\xb0\xff\xd0\xe1\\vN\xfd\
\x04Z=$W2\x85\xc9\x1d\x00\x00\x00\x00IEND\xaeB`\x82h\x18Z\xef' )

def gethtmlBitmap():
    return wxBitmapFromImage(gethtmlImage())

def gethtmlImage():
    stream = cStringIO.StringIO(gethtmlData())
    return wxImageFromStream(stream)

def gethtmlIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(gethtmlBitmap())
    return icon

#----------------------------------------------------------------------
def getimageData():
    return zlib.decompress(
'x\xda\x01\xdf\x02 \xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02\x96IDATx\x9c\x8d\x93KHTq\x14\x87\xbf{\xc7\
\x19\xd3L\xa7k\x91\xca\xcc\xd4hP*\x9aA \x12\x19B\x98\xf6\xd8\x04\x81\xd2&Z\
\xb8h\xd3>Z\x86\xd0\xaa\x16\xb5\xd3 \xe9\xb1j!TN\xd1C\xc2EmR\xe8\xa1B\x8c\
\x93\xd7\xf7s2g\xe6\xce\xdc{\xff\xa7\xc50\xf62\xea\xb7:\xe7p\xce\xc7\xef\x1c\
8\x9a\xdf\xef\xe7g\xb5\xb5\xb5\t\xffP$\x12\xd1rq\xdef\r\xdd\xdd\xdd\x7f\xd4\
\xa2\xe3\xef\xe9\xb9\xf3\x80\x96\x96\x16\x00\xc9A6\x05\x00\x84\xc3\xe1_\xf2\
\xa2\xa2"v>yNWWW\xae$\x91HD\xfb+\xe0w\x19\x86\x81\xc7\xe3axxx\x03266&\x1b\
\x80\xab\x8e.W\xf2\x94\xf6%\x1ef\xc8\xde\x81\xfe5\x8d\xee\xfb\xc2\xc4\xf42G*\
\x1b\xd1u\x9d\xf2\xf2r\xfa\xfa\xfa\xe8\xed\xedett4;\xe8\xf7\xfb\xb9e\xec\x12\
k\xe8\x9e\xbc\x08\x95\xcb\xcdwQ9\xf6p\\\x1a\xcf\xdf\x90\xa85"\x9dw;\xa4\xbe\
\xbdE\x06\x07\x07%\x99H\xc8d,*\xcf\x07\xfa\xe5\xfa\xb5\xab\xd2\xd0\xd0 z]<.\
\xadg\x9bX\xee\xbd\xcdBR\xf1x\xc6f>j\xa2\xcf\xcd\xf3\xf4s?c\xf31\xd6\xbd\t\
\x06\x06"L\x991\x0c\x7f1\xb5\xd5\xfb9PW\x0b\x80n\x95\x95\x91\x98\x9e\'\xfe1F\
Ig\x07\xfb\xb6\xe5\xe3Y^\xa5\xb9\xd1\xe0\xd9\xe8+\xd6\xcc\x14\xcd\x15\xf5|[\
\x8b\xb3\xb40\x87\xb8)\xf2\xf3=(k.\x0bH\xed\xd8\x89}\xaa\x835\xe5\xb2\xab\
\xf90\x07K=\x18\x8b1B\xc1\xed\xf8>\x07\xd0&\xb6PZX\x82R\x0eN\xc6\x02\x95F\
\xd9\xd6\xc6q\xf3@\xc8\xec\xaf\xc7W\xe4\'\xd8\xdaJ\xe1b\x9c\xf5\xa6 \x01\xc3\
K\xddR\rU\xd5A\x1c\xe5"\xcaE9Vv\xd8M\x82\x9b\xce:\xd04\r\xef\xc8[\x02\'O\xa0\
\xeb^te\xd3P\x13\xc0WP@e\xb0\x92\xe2\x92\x124M\x03\x11\x94\x93\xc6\xcd$\xc1\
\xb1\xc0\xcdd\x1d\x98\xa6\xa9]\xe8\xb9+\xe7\x8e6\xb1\xe7Q?\xc1@\x05\xb3\xb3K\
L\xc4\xa2\xac\xac\xac099\xcdj|\x99Cu{AePN\n\xd7N\x83\xb2s+\xc0\xd4\xd4\x94v\
\xff\xf5\x1bq^\x0e\x11\n\x85\x08\xef\t!\xe2\x82\x12\xb6\x15\xeaT\x05\xf7R\
\xb5\xbb\x8c\xe2B\x1fn\xc6B\xd9\xa9\x1f\x0er\xc70MS\x03hoo\x973\xa7\x8f\xe38\
\x16\xcaIg\x1b]\x9b\xe2\xad>\x82\x15\x06\xcaNe\x01*\xfd+ \xa7\x99\x99\x19t\
\xdd\xc5\xe7\xf3\xa2t\x1b\xb1\x05\x11\x9b\xf5ok|\xfa`"v\n\xb1S\xa0\xdc\xcd\
\x01\x00\x17/]\xfe\xdf\x17\xe1;F}8\xc5\xb3+\x8d\xd6\x00\x00\x00\x00IEND\xaeB\
`\x82\xde\x8b\\M' )

def getimageBitmap():
    return wxBitmapFromImage(getimageImage())

def getimageImage():
    stream = cStringIO.StringIO(getimageData())
    return wxImageFromStream(stream)

def getimageIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getimageBitmap())
    return icon

#----------------------------------------------------------------------
def getxlsData():
    return zlib.decompress(
'x\xda\x01a\x02\x9e\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02\x18IDATx\x9c\x95\x93\xcdk\x13Q\x14\xc5\
\xcf{\xd1&fj}\xbap\xe3\xa60\xb3\xc8\xff`\xb2T\xab\xa5u\xa1qQ\x11B>\xac\xb4L#\
\xb6P$\xc1U\x96\x11\x0cE\xb3h\xbb)\xc4TA\x04\x17b6U\xc9F\xd3M@\x91\x083+\xa1\
C\xb1-\x81RS\xa9\xe9q\xd1d\xfa\x95\x80\x1ex\\\xde\xc7\xfd\xdds\x1f\\\xa1\x94\
\xc2A\r\x0c\x0c\x10GT\xab\xd5\x00\x00\xd5j\x15\x00\xa0\x94\x12\xed\xbb\x13G\
\x1f\x03@&\x939v\xe68\x0eL\xd3\xc4\xcc\xcc\x0cB\xa1\x10\xdb\x90\x8e\x00\x00\
\xd0u\xfd\xd8>\x10\x08 \x18\x0c\xc2\xb2,\x18\x86A\xa5\x94\x90\xdd\x00\xddd\
\xdb6t]G\xb9\\F\xbd^gW\x07\xdd\x94N\xa7\x01\xec\xff\xcb\x7f\x01\x8a\xc5"l\
\xdb\x86\xe38\xb0m\x1b\x91H\x04\xc2\x97<\xcf?\xfe-\x00@s\xa7\x01\xe9\x05z7{P\
\xcf5\x00\x00\xc9D\x0c\r\x0f@\xd9\x034ObW\xaec>_\x80m\xdb0\x0c\x03PJ\xe1\xcc\
\x84\x8f\xe4[V\xb6\x92,m\xc7X\xda\x8eQLI\x86\xcd\x08\x7f\xad\xfe\xe6re\x99\
\xa3\x89\xfb\x14R\xf2\xa0\x00P\x02\x80X\xf0\tm<\x01\xc3?\x88\xb3\xcd^\x00\
\xc0%\xef\x10\xe2\xe3\xc3\xf8\xf2\xe3\x1b\ns9\xcc\xce\xcdb\xb7\xd9\x04\xf0\
\xb1\xd5P+*\xa5\xa0\x94Bi\xe1\t\xfdc\x17\xb8\xd3\xac\xf0\xc6\xf4U\xbe\xfb\
\xbe\xc4Ta\x92\xc3\x937\x8fU\xa6\xb5\xe8:p\x01\x8b/\x0bt6Wx\xeb\xd15\xbe\xf9\
Z\xe2\xe3\xf7Y\x0eN_\xa6\x14\x1ae\x14$?\xb4\xb2\xf7\xe3!\xc0\xfc\xebW|\x10\
\xbb\xc7\xd5\x9f+\xcc-=\xe5\x95\x87A\xa2\x17\x94w\x14=)I9"\xdc\xca\x1d\x1d\
\x98\xf11\xaem\xac\xb3\xf0\xe23\'\xe2Q\n)\xd9\x13>M1%\xd9\x97?\xd5\x82\xf4uv\
\x90\x18\x8drmc\x9d\xcf\x9f\xe5\x19\xbfk\xba=\xcb(\xe8\xfdt\x91Z\xd6G-\xeb\
\xa3\'\xb5\x07\xdds\xd0\x02\x98\xf11\n)\x0f-\xcb\xb2\xdcJ\xdamA\\\xd7(G\x04e\
\x14D\x18<7\xa4\xb9\x00qt\x9c\xfb\xfb\xfb\xd9\x1e\xdb\x7f\xd1_eKU|F\x06\xe8\
\xaa\x00\x00\x00\x00IEND\xaeB`\x82\xf3w\t\xb4' )

def getxlsBitmap():
    return wxBitmapFromImage(getxlsImage())

def getxlsImage():
    stream = cStringIO.StringIO(getxlsData())
    return wxImageFromStream(stream)

def getxlsIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getxlsBitmap())
    return icon

#----------------------------------------------------------------------
def getpptData():
    return zlib.decompress(
'x\xda\x01\x8a\x02u\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02AIDATx\x9c\x8d\x93MH\x94Q\x14\x86\x9f\xef~\
138F\x17"\xc9]0C\xd8\xa2\xc2\x1f\x84\xc4\xa1\xdc\x84\x8b\xdc\x14D`\x81\t\x83\
\x1b\x87\xd6\x91-"\xabE!\x85\x1a$R\x8b\xcc\xb2"\x8a\x88\xa0EL\x8c\xfdPZ\x82B\
C\xcclB\x18\\\x08\x03\xf939\xf3\xf9\xb6\x18\x1c\x1bM\xe8\x85\xc3\xe1\xdes\
\xee{\xcf}\xe0:\xd6Z\xfeVkk\xab\xd8\xa0d2\t\xc0\xd4\xd4\x14\x00\xd6Zg\xad\
\xb6mc3@oo\xef\xa6\xbdL&C,\x16\xa3\xbf\xbf\x9fH$\xa25\x93\x7f\x1a\x00\x84B\
\xa1M\xeb\x9a\x9a\x1a\x9a\x9b\x9bI\xa5R\x84\xc3aYk\x1d\xb3\x95\xc1VJ\xa7\xd3\
\x84B!\x12\x89\x04\xd9lV[N\xb0\x95zzz\x80u.\xceF\x88W\xc3y\xf9V\x97\xf0\xe3\
\xb0L\x80\x95\xe02\x95s"\xd8t\x88\xdd{\xf7P}\xf22\x99L\x86t:MGGG9\x83\xd7\
\x17\xa3\x9a|~\x83\xb3\xf1i\xb237\xf1!|rp\x0b;\xc9\xad\xcc\x12\xfcVEw8\xcc\
\x80Duuu\xf1\x90\xb5\xb6\x14\xf7\xeb\x8c\x16\x9eD\x95{sN\xf9x\xa7n7\x04U\x89\
+\xd7\x18\xe9\xfaQ-\xbd=#\xf5G\xd5\x85O\x92\x04\xa8\x0cb\xce\xddA\xc5\xf1(\
\xfe\xdf\x1e\xde\xe8\'b_\x97\x99[\xcd\x93/\x14\x18~\xfc\x05\x7f\xcb)V\x92?y\
\x80\x07\xbc\x03\xa0d\xf0\xecJ\x97\x1c/[4\x9a\x9fed\xe2;\x00\xf7jwq\xb7\xc1\
\xa5\xf3\xf3\x08\x8b\x0f\xef\xe0\x06r,\x1b\x01\x87\xcb\x9f\xd0\xd7\x88\xf4\
\xb2[KCmZ\x1c:!)\xa1E\x8d\xcb\xf3f$%\xb4\xf0\xa1]\x1a<\xa6\xf1ZG\x95\xb8\x92\
\xe2\x02\x84\xb5\x96W\xb7.h\xb8\xce\x91\x94\x90w\xa9I+G\xb6\xeb\xfd\xfe\x80\
\xa6\xeb\x1dM\xd4\xa2\xe9zG\x03\xf5V\xae1E\x1e\xa9G%\x06Xk\x19\x888\xca\xbd8\
\xad\xec\xf9}\xf2Z(5V\xe2\xca8A\xb9\xc6h\xa8\xaeBE\xc5K\x19\x90yz-&\x00\x7fK\
\x1b\xfey\xcb\xc7l\xf1\x9f\x14<\x8f_*\xe0\xad.P\xf81Jtr\x11\xd2c\xc5\xb7\xa7\
\xc7\xd6\xc9\xf75"\r\xb6\xcbkA\x13\x07\x1c\xb9\xc6(\x95J\x95\xdd\xb49\xc7\
\xd7\x19\x0c\x1d4\xa51\x03T\xc95\xa6X\xf8\xcf\xf8\x03\xd4IS\xd7\xc2E\x83}\
\x00\x00\x00\x00IEND\xaeB`\x82\x8bt$:' )

def getpptBitmap():
    return wxBitmapFromImage(getpptImage())

def getpptImage():
    stream = cStringIO.StringIO(getpptData())
    return wxImageFromStream(stream)

def getpptIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getpptBitmap())
    return icon

#----------------------------------------------------------------------
def getdocData():
    return zlib.decompress(
'x\xda\x01\x96\x02i\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02MIDATx\x9c\x8d\x93OH\x94Q\x14\xc5\x7f\xef\
\xa9\x833Z~\x81Q\x81\x0b\xe1\x93p\xd5\xa6\x955\xe2\xd6hYh\x05\x81\xbb\x88\
\x98\x8d\x8b\xa2P\x88\x18\xa46F\xb8\x88\x16a\xf4\x8f\xb4\xbf\xe8F[\x142\xa2\
\x89\xa1\x86\xa2\xa3\xce\x87T\x93\n\xe3L\xd3\x0c:\x8e3\xf3\xdd\x16\xea\xf8g\
\x1a\xe8l.\xef\xbc\xc79\xe7\xde\xc7U\x86a\xb0\x1b\xf5\xf5\xf5\xc2>\xf8\xfd~\
\x00&&&\x000\x0cCm\xdf\x15\xee\x7f\x0c\xe0\xf5zs\xb8\xa5\xa5%<\x1e\x0f\x1d\
\x1d\x1d\xd4\xd6\xd6\xca\xb6\xc8?\x05\x00L\xd3\xcc9WWW\xe3v\xbb\t\x04\x02TUU\
\x89a\x18J\xe7\x13\xc8\x07\xcb\xb20M\x13\x9f\xcfG4\x1a\x95\xbc\t\xf2\xa1\xa5\
\xa5\x05\xd8\x99\x8b\xaay8%\x12_\xde$\xdb\xce\xab\xca\xdb\xdd\xe2\\w\x12:\
\xe0"\xf4\xf1\x1d\xd1\x0f^\x8a.\xb6rl\xc3\xc5\xaa.\xe6P2\xc9\x93\xebn,\xcb\
\xa2\xa9\xa9\tN?\x1e\x93\xd1\x8c-.\x10\xc30PZ\xcb\xa4\xc4e4c\x8b\xd2ZDD\x94\
\xd6\xf2lN\xe4\xf2\xfb\x85,\x17\x08\x04\x04\x90\xc2L8\xc2\x86V$t9\x89XD\xcc\
\xf6\x19\xba-avj\t\xa7m\xa3\x0bJ\xb8\xd05\xce\x8b\xcf#\xf4_=\x85\x9d\xc9\xec\
\x19\xb2\x8e\x86\xe38l\x01"\x94uNq\xee\xccq\x82\xdfV\x18\\\xb3Ih\x17\x97\xba\
g\x88-\xfe\xe1\x93/\x85\x94\xd8\xc0\xc0\xd64\xb6\xea\x89k\xcfeR\xe2\xa2t\xb9\
xgD*\x9eF\x04\xf7M\xb93\x9f\x14\xa5\xb54\x07#Rzk0\x1b}3\xff+\x11\x11\x01D\
\x873\xc5\xc4(\xa5u>D\xe7P\x88\xe0\xa36\xd4\xd0=\x8e\x94\x16qc!\xc6\xf7\x1e\
\x0b\x99\x8e\xef\xfa\x87\x010\x1b\xb3\ttb\xe5\x07\x8e\xf4\x1ao\x7f\t\xd6\xf4\
,j\xb8\x1d\xa9i\xc6\x95N\xf3\xb5o\x8c\xde\xa0\x83\xb5\x9e\xb3\x9b\xbd[]@\xdd\
N\x05\xf4F(\x06\xdaI\xe0\xcdk\xd4\xfd:\x1a\x1b\x1aP\xa9b\xe2"\x0c/8I\xf7?\
\xc8u\xde\x9d \xb5\xbe\xca\x95\x91(\xea\x8b\x1f(\x06@J\x7fs\xb7w\x99\xe4b\
\x04{\xba\x0f{\xee\xe5^g\xab+\xdbPa*\x1df\xdc]\x01\xb8(;\xe8P\x80\x1c^+\xe0\
\xa7\xe7$N{\x85\x8c\xd6\xb9\xce\xe6\xd1\xac\x80\xda\xbf\xce\x95\x95\x95\xb2\
\xbd\xb6\xff\x83\xbf\xa6\x17*\xb5^RW\x08\x00\x00\x00\x00IEND\xaeB`\x82*\xf6,\
\x8a' )

def getdocBitmap():
    return wxBitmapFromImage(getdocImage())

def getdocImage():
    stream = cStringIO.StringIO(getdocData())
    return wxImageFromStream(stream)

def getdocIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getdocBitmap())
    return icon

#----------------------------------------------------------------------
def getpdfData():
    return zlib.decompress(
'x\xda\x01\xd6\x02)\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02\x8dIDATx\x9c\x85\x93]HSa\x18\xc7\x7fg\x1f\
\xce\xcd\x93\x9e\x89\x1b\xce4\x92UT\x12-5\xba\xab\xc4\x9b\xdd\x15\x95\xb7\
\x05}xQ\x83\x08\xba\xc8\x88\xa0\x1b!(\xa4\xe82\x03-\x88(\xba\xc9t\x90hX`D\
\xb4\xb9jS\xc32\x96\xb9\xd9\xc4A\xee\xe3x<\xe7\xedB\xfc(\x17\xfd\xaf\x9e\xe7\
\xe1\xe1\xc7\xff\xfd\xf3>\x92\xa2(\xac\x95\xdf\xef\x17\xfcG\xc1`PZ\xae-\x85\
\x16\xda\xdb\xdb\xd7\xcd\xbe\x8c}\xe0n\xd7C\x9a\x9a\x9a\x00\xc42\xa4 \x00\
\xa0\xb6\xb6\x16\xd4\x1cz~\x01QR\x82,\xcb\xb8z\xfbimm]^\x11\xc1`P\xfa\'\x00`\
\xfc\xe6\rL\x99_\x18\'N\xe3\xf5z1\x9b\xcd\x84B\xa1\x15\xc8\xe8\xe8\xa8(\x08p\
\xbb\xdd\x84_\x0e\x90\x8bD\x89X%\\\xc3\xaf\xd1fg\xf0x<tww\xd3\xd9\xd9I,\x16[\
\x9f\xc1\xd0\xd0\x900\x99L\xa4R)\xaa\xcd\x16\x86U\x95\xa6\xab\xd7H\xce\xa6\t\
\x87G8\xdc|\x10{\x85\x8b\xf1\xd8\x07\xb6l\xf2\xd0\xf5\xf0\t\xa6\xb5\x80L&\
\x83\xcbU\x81\xa7\xb8\x88\xc8\x83\xfb$\xe5\r(eN\xbc^/[\xea\x1b\x19{;\x8c$t\
\xeavlg\xf7\xae:\x80U\xc0\xe0\xe0\xa0\xa8\xa9\xa9\xc1:\x97\xa6\xbf\xad\x8d\
\x92c-\x1c\xf0\xf9\x88\xbf{O.\x97#\x1e\x8f\xa3\x1b\x82\xa9\xf8$6\x9b\x19#\
\x9fX}\xc2\xe4\xf5+b\xf4\xf6->\xe5\xb3X\xf3\x1a\x8e\x92\rlz;L\xb1d!\xf2\xec)\
5\x9eJ\x12\x89\x04\xd5\x92 \x9dNah\x9e\x15\xd7\xa6\xf1\x93~\xd1\xf3\xbc\x8f\
\xe9\xb9\x19\xa2\xaaJe\xdb%\xec\'\x8f\x13\xa9\xac\xe6U\xf2\x07\xca\x9bw\xd8n\
w\xb0\x7f\xa3\x9bo_?cA\x07=\x0b\xba\xba\xe4`\xdb\xbd\xa0\xd4\xb1\xc7\'\x06\
\x14+\x87\xce\x05\xd0\x8b\xed8l6,\xa5\n\xf8|X\xf2p\xe7E\x1fg\xbe}\xc4\xdc\
\xec\xc7Yj\x87\xc5<\xe8\x0b\xab\x19\\\x08\x85\xa5}G[\x08\x87F\x98K\xa7\x99N$\
\x89\xc7\xe3\xcc\xcf\xcf\xf3H."P\xa5P^U\x8e^\\\x84\xd5,\xd0\xb5<\x18\xda\x9f\
!\x06\x02\x01I\x96e&&&\x88F\xa3\xa8\xaa\xca\xeb\xde\x1ev\xba\xcb\xe9o\xa8\
\xe7\xf1\xf6\x06\x9c\xa5v\xcc\x92\x8e\xa1eW\x1cH\x7f\x1f\xd3\xa9\x96#b\xef\
\xd6\xcdd\xb3\xf3\xa8\x16\x0b\x92\xec\xa0\xc2)\xe3r\xca\x94\x979\xa8P\x1c\
\x18Z\x8e\xd8\xa7\x11.v\x04\xd7\xdf\xc2\xd4\xaf,G\xf75\x02`,f\x11Z\x0e\xa1\
\xe50\x163\xa4\x92)~~_\xea1\xf4\xf5?qYg\xcf_.4.\xa8\xdf\xb9\xe3\x0c\xb2M\x95\
\x1ad\x00\x00\x00\x00IEND\xaeB`\x82\xdb\x9fV\x9d' )

def getpdfBitmap():
    return wxBitmapFromImage(getpdfImage())

def getpdfImage():
    stream = cStringIO.StringIO(getpdfData())
    return wxImageFromStream(stream)

def getpdfIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getpdfBitmap())
    return icon

#----------------------------------------------------------------------
def getrpmData():
    return zlib.decompress(
'x\xda\x01\x95\x02j\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02LIDATx\x9c\x8d\x93OH\x93q\x18\xc7?\xef\xfe\
\xf6\xe2[\xbd\x0e\rd\x89J\x11E\x17\xefvHC\x1bx\xd3\x8b^\x0c"\x06EP\x87\x92\
\xf2P\xd0\xc1D(\xba\xd5\xc1\x11\xdaa\xfd\x91(\x86\xb2pX\x07\xa1\xda\xa1A\x0b\
6;\xb8D\xacU\xea&\x94\xaf\xf3\xdd\xde\xa7\xc3\x9c\xf9gR\xdf\xcb\xefy\x1e\x1e\
><|\x9f\xe7\xa7\xe8\xba\xcef\xf9|>\xe1\x1f\n\x87\xc3J)v\x94k\xe8\xef\xef\xdf\
Q\x9b\x99\x8e34\x1c\xa4\xb9\xb9\x19@J\x90\xb2\x00\x80\x86\x86\x86-\xb9\xa6iT\
\x8fG\xf0\xfb\xfd\xa5\x92\x84\xc3aeW\xc0vy<\x1e\xecv;\xb1Xl\x03\x92L&\xe5\
\xbf\x01v\xbb\x9d\x9a\x9a\x1aFFF\x08\x04\x02$\x12\t\x00\x94\xcd&6\x9dh\x92\n\
\xad\x02\xa7\xd3\x89\xeaVq:\x9d\xcc\x7f\x9d\xe7rg\x07\x87u\x9d\xaaS\xad,\xfc\
\xfc\xce\xe7D\x9c\xf8\xc78\xc3\xc1\xd1\xa2\x07=gz$\x14\n\x81\x02\xb5\xdeZ\
\xba\xbb\xbb\xf1x<TVV\x92\xc9d\xf85\xfb\x85\x99\'AR\x0f\x03x{\xafr\xfc\xd8Ql\
bAp\x14::;\xc4\xedvI]}\x9d\xe8\xbaNWW\x97\xa4R)\xd9,\xcb\xb2\xc4\\\xfd-\x93m\
-2q\xb2I>\xbc{-\x91\xe7\xf7\xa5\xb1\xb1Ql\x9f\xe2qL3\xcfrvyc\xb7"\x7fOA\xc4"\
\xbf\xb6B!o\x10s8\x88\'\xa6IG&\xb7\xf8#\x9a\xa6I\xdb\xe96Y\xf7C\x8a\x0c\x91\
\xa9\xa9))\xe5\xe7\xce\xf6\x08 \x03\xb7\xae\xc9\x9b\xb1G\x12yv\xaf8\x01\x80\
\xc3\xe1P\xa2\xef\xa3J6\x9b\x95\xde\xeb\xbdLN\x84Q\x14\x85h\xf4-\xde\x83^\
\xc6_<&4\xf6\x8a\xd0\xd3!\x06\xee>P\xf6\xaa.(\xac\x01`\xdb\xbe\xae\xc1\xdb\
\x83\xb4\xb4\xfa\xb8y\xa3\x8f\xe5l\x06\x80=\xaeb\x9b\xba\xfe.--\x80e\xee\\\
\xa3a\x18\xd2\xde\xde\xce\xc5\xf3~*T\x17\xd5U:?\xbe\xcd\xb3Os#\x85\x1c\x053\
\x87U\xc8!f\x8e\xc5\xf4,W\xee\xbc\xdcz\xca\xaa\xaa*.\x97K\xea\x0f\x1d\xe1\
\xc0~;\x96i\xe0\xd1j\xb1\xd6V\xb1\xf2\x06\x85\xbc\x13\xcbt`\x996\x16\xbf\xe6\
\x80]\xfeBz.Iz\x0e\xac\xfc\nb\x1a\x88i`\xe5\x8d\x8dXL\x03\xac\xc2\xee\x80\
\x0b\x97\xfa\xca\x95\xcb\xea\x0f\x92\x1a\x14,s\x96,3\x00\x00\x00\x00IEND\xae\
B`\x82\x1eK1\x00' )

def getrpmBitmap():
    return wxBitmapFromImage(getrpmImage())

def getrpmImage():
    stream = cStringIO.StringIO(getrpmData())
    return wxImageFromStream(stream)

def getrpmIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getrpmBitmap())
    return icon

#----------------------------------------------------------------------
def getshellscriptData():
    return zlib.decompress(
'x\xda\x01j\x02\x95\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02!IDATx\x9c\x85\x93?O\x94A\x10\xc6\x7f\xef\
\x9f@b\x88\xb9\x184(\x01%\xb1\xd0\\\x8c%\x15\x05\x1d\xdf\xc3\x04\xa2\xc5\xd9\
\xfb\x01\xf8\x00\xd4\xd7\x10\n\x1a[\xcc\x15R\x13*\n\nP\x12\tZ \x90\x90\xe3xo\
\xdf\xb9\xdb\xdd\x19\x8b\xf3^\xbcx\xc6I&\xfb\xecd\xe7\xd9\xc933I\xadV\xe3O[Y\
Y1\xfec\xadV+\x19\xe2|\xdc\x83\xf5\xf5\xf5\xbfb\xdf\xbe\x1c\xd2\xdc\xdcfyy\
\x19\xc0\x86$c\t\x00\x16\x16\x16F\xeeSSS<\xfc\xf4\x99\xd5\xd5\xd5a\xc8Z\xadV\
\x92\xef\xef\xef\x9b\x88\xe0\xbd\xc7{_%\x9c\x9e\x9eV\xd8\xcch\xb7\xdbdY\xc6\
\xc1\xc1AEr||l\xc9\xee\xee\xae\xed\xec\xec\x90\xa6i\xe5I\x92`fUr\xbd^\xe7\
\xec\xec\x8c\x89\x89\t\xce\xcf\xcf\xf1\xdestt\xc4\xf5\xf55y\x8c\x11\x11aqq\
\x91\x93\x93\x13.//\xb9\xb8\xb8\x189\xb7\xb6\xb6\x10\x11\xd6\xd6\xd6\x10W\
\xf0\xf5\xe8\x90\xe7\xf3\x8f\xd9\xdc\xfeH\xaa\xaa\x98\x19KKKLOO333\x83\x99\
\x8d8\x80\xaa\x12\xbd\xf0\xa0v\x9f\xfa\xcb\x17\xbc~U\x1ftAU\x11\x11666\x10\
\x11\xda\xed6eY\xd2\xeb\xf5*]\xcc\x0c\x8d\x81\xe8\x05\x8b\t\x93\x93\x19*?\
\xef\x08\x86\t\xfd~\x9f\xa2((\x8a\x02\xe7\x1c"B\x08\x814MQ\rh\x10\xd0\x14\
\xf5R\t\x9c\xab*\xce9\x9cs\x84\x10p\xceq{{K\xa7\xd3\xa1(\nT\x95,\xcb\xb0\x18\
Q/\xa8O!:\x88\xbd;\x82n\xb7\xcb\xd5\xd5\x15!\x04D\x04\xe7\x1c777\x88\x0c~\
\xca\xf3|P\x81/\x89} \x08\x03\xc0\xa0\x0b\x8dFc\xa4m\x00i\x9a\x92e\x19y\x9e\
\xd3\xe9t*\r4@\xf4=\xd0\xc1\xcc\xe4\xcdf\x93n\xb7\xcb\xb0\x1b\xb3\xb3\xb3<{:\
\x8f\xc6\x80i@5`\x1ay\xf2\xe8\x01\x89\xf5\x89}P_\xdeU\xb0\xb7\xb7W-\x06\xc0\
\xdc\xdc\x9c5\xde\xbe!\x04A\x83`^P\xdf#\xb1>\xf7&3\xd4\x97\x03\x02\xfd\xad\
\xc1\xb8=\xf8\xfec0\xc6\x1a\x1c\xe6K\xcc\x97h(+l\xbe\x04\x8d\xff&x\xf7\xfe\
\xc3\xb8\xf0X\xfb\x05\xc9\xe3\x8b\xf8\xe9\xd2#\xcb\x00\x00\x00\x00IEND\xaeB`\
\x82\x96Q\x1a\xc6' )

def getshellscriptBitmap():
    return wxBitmapFromImage(getshellscriptImage())

def getshellscriptImage():
    stream = cStringIO.StringIO(getshellscriptData())
    return wxImageFromStream(stream)

def getshellscriptIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getshellscriptBitmap())
    return icon

#----------------------------------------------------------------------
def getsoundData():
    return zlib.decompress(
'x\xda\x01\xae\x02Q\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02eIDATx\x9c\x85\x91MHTa\x14\x86\x9f\x99\xab\
\xcd\xd5\x19\xe7^\'\x0bL1g\x02\xb1\xd4\xb1\xa5-\x876\xe2\xae\xda\xe4\xd6h \
\x11\x0c7e\x88\x84\x90\xd0&h\xdf&7aD\xcb\x98\xa06\x11Y\x14M?\xa3f\x93\xa2\
\x0eX\xf8\xd7\xd8\xc8\xbdw\xee\xcf\xf7\xb5\x90Q\xab\x91\x1e\xf8\xe0\xe3p\xce\
\xc3{8>]\xd7\xd9Oww\xb7\xe4?\xa4R)_\xe9_Q\xaea||\xfc\x9f\xda\xc2\xdcg\xee\
\xdd\x7f@"\x91\x00\x90%IYA4\x1ae`\xf8:\x00\x97/\xf6\x12\x8f\xc7\t\x85B\x1cy\
\xf2\x8cd2Yj\x93\xa9T\xca\xe7\xff{XJ\xc9\xa5\xab\x83\xbc\xd9\xdc"\xf75\xcb\
\xe8\xd8\x18\xb9\\\x8eH$\x82\xa2(\xa4\xd3i\x92\xc9$\x89D\x82\xe6\xe6f\xf9\
\xaf\xa0J\xe5i\xf7\x05\x9a\x84 \xd6\xd4Dsc#\xb3\xb3\xb3(\x8aB}}=\x13\x13\x13\
\x0c\x0c\x0c099\t\x80\xa2\xaa\xea\xeep\xbe\xe3\xb4\xcc_\x19\xc2\xfbU\xa0e\
\xfa=\x9a\xa6\xe1\xf7\xfb1\x8bE:\xda\xdb9\xd3\xd5Eg\xbc\x9d\xa3\x91\x1a\xf4\
\x9a \x1f33\xf8\xf7\x0f\x1f\x1f\xbd\xc5J\xb0\x96\x8a\xf9\x05\x14EA\xd7ub\xb1\
\x18\x00\x1b\x1b\x1bTV\xf8\x88\xe8a\xdaN\xb6\xd2\xd9\xd1\x06\xb0#\xc8\xb7\
\xb4J\xff\xf0Mr\xae\xc0\xbf\xbdEo\xbc\x85\xbe\xbe>\x1a\x1a\x1a\x88F\xa3X\xb6\
M\xfe\xe7:\x9ec"=\x93@@AX?\xf6\xce\xe8\xcb-\xc3\xa3\x87\x10\n!\xab\xaa\x99k8\
F\xf1[\x86\x91\x91\x11l\xdb&\xf3e\x06\xcf6\xf1\x1c\x0bD\x11\xe1X\xbbkW\x00h\
\xa6\xe1+\xac,K\xa9\xd5\x82v\x98\xb5j\x95\xfe\x9e\x1e\x02\x81\x00\x9a\xa6!\
\x85\x8bp\x8b\x08\xc7D\xb8\x16x\x06x\xc5\xbd\x15\x00j^\xbf\xf4\xf1v\n\xb6\
\xb7\xa8\xf3\\TUeuu\x95B\xa1@a}mG`\x1bx\xb6\x01\xae\x05\x9e\xbd\x97\xa0Dxs\
\xddW\x99I\xcblXCJ\x89a\x18d\xb3YZ[\xa2\xf8\xf1\xf0\xdc\x9d\x04\x9eS\x04\xe1\
\xfc\x99\xa0\xc4\xd9S\xad\xe8\xdf\x17\x99ZZ"\x18\x0c\xf2\xea\xc5sBU\x95\xe8\
\xa1C\x08\xdb\xc4\xb3-\x84c\x94OP\xe2\xf1\xdd\xdb\x9c\x1f\xbcF\xfa\xc3;\xceu\
\x9c\xa0N\x0f\x12\t\xabx\xae\x85p,\x84c\x82(\x1e,X\\\x9a\xe7\xceP\x12\xe1\
\x1aH\xc7D8\x06\x99\xe9OH\xc7\xdc}\x08\xef`A\xff\xe0\x8dr\xe5\xb2\xfc\x06\
\x91\x86\x15\n\xba\xd1\x9d9\x00\x00\x00\x00IEND\xaeB`\x82qM=\xc7' )

def getsoundBitmap():
    return wxBitmapFromImage(getsoundImage())

def getsoundImage():
    stream = cStringIO.StringIO(getsoundData())
    return wxImageFromStream(stream)

def getsoundIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getsoundBitmap())
    return icon

#----------------------------------------------------------------------
def gettarData():
    return zlib.decompress(
'x\xda\x01\xbc\x02C\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02sIDATx\x9c\x85\x91\xbdOSQ\x18\xc6\x7f\x97b\
K\x01\xa1\x81\x90\x1a4H\x1d\x08\xa4&\x100qP\x13\x184\x18\x07f\x17Q\x87\xfe\
\x15\xae\xe0\xc4\xe0J\\`a\x11\x8d\x89\x916\x12\xd9LHH0TS0*\x05\xd4\nm\x8az?\
\xce\xbd=\xf7\x9e\xe3\x00\xe5CH|\xa6\xf3\xbc\xef9\xbf\xbc\xefs\x8cX,\xc6Q\r\
\x0f\x0fk\xfe\xa3t:mT\xcf\xb5\xa7]\x18\x1f\x1f?Q\xfb\xba\x96\xe5\xe9\xd4\x0c\
CCC\x00\xba\n9\x15\x00\x90H$\x8e\xf9\xc6\xc6F\xda^\xcf\x93J\xa5\xaa%\x9dN\
\xa7\x8d\x13\x80\x9b7\xe2,\xcc=aa\xdf\xdf}\xf0\x98h4JKK\x0b\xa1P\x88\xe5\xe5\
\xe5\x03\xc8\xea\xea\xaa6\xaa\x19L\x8c\x8dj\x80{\xa3)\xe6\xd2\xaf\xb83\xf2\
\x90\xddR\x8e\x97\xcfg\x01\x18\xb8\xf6\x80L&C\xa1P@JI.\x97\xa3\\.c\xc4b1&\
\xc6Fu[\xbc\xfd\xd8$\x15\xdf \\{\x98gq\xfb\x07w\xef\x8fS*n\xf3)\x97%\xbb\x92\
ej\xe6\xd9^\x06\xe1\xba8wF\x1eb\x18Q\x94,\xa1\x95\xcf\xdc\xdc,\xfd\xfd\xbd46\
\x84q\xed\x12\xf3\xf3k\xac\xbc_\xe2r2I\xb2\xa7\x9b\x1a\xad\xa0\n@\x0b\x94\
\xb7\x83\xf4~\x11i\xeaBK\x13\x80\xfap\x85\xcf\xd9\xb7\xac\xe7?\x90\xffR\xe4B\
\xc2D\x07\x82H$\x84r\x7fr\xf0\x0b\xbe_\xc1\x08w\x109\xd3\xce\xef\xefo TO\xbd\
\xb1\xce\xd2\xbbeL\xd3\xc4\xb2l,\xd7\x05U\x01\xe5\xa1\xa4{\xb0Z-\x80\n\\\xdc\
\xdf\x1f\xb1\x8b\x1dh\xd9\x89\xa9\xbeC\xb0\x8bm\xd9\x98\xb6\x8de\x0b\\\xd7C\
\xf9\xee\xde\xe3\xc0\x81\xc0;\x04HYa\xa7\x90\xa7A*\x1cQ&|v\x1d\xcb\x12\xfcq\
\x04\x8ep\xb1\x84\x83m\xbb(\xdf#\xa88\xe0\xbb\x10T\x8e\xac ]jCE\x84Q\x00\xc3\
\xc1\xf3\x03,\xc7\xe1[\xbe\x8cQ\xe7c\xda6\xa6\x10\xa0$\xca\x17\x04\xd2\x03%\
\x0f\x01\x8f\xc6^\x18\x9b[?\xf4\xad\xc1n:\xce7\x13H\x8f\xcd\xfc.?\xb7mTH\xa2\
j\x9a\xb9\xd2{\x9b\xa6\x860A\xc5EIq|\x02\x80\xc9\xe9Ecrz\x91\xd4\xbd\xab\xfa\
\xd6`7[\xe5\x00\xce\xd4\xd3u\xe9:\xc9\xee$\xf1\xd6&\xce\xc5[QR\xec\x01\x94w\
\x1cP\x95\x11\xed\xc3\xd5\t\x06\xfa\xa2t^\xec!\x12\xa9AK\xc1\xee\xaf\x12\xe5\
\xe2\x16Z\n\xb4\x14\xa0\x82\xd3\x01\x1b\x1b\x1bd2\x99}\x97\xfe\xb7}B\x7f\x01\
v\x1dD\xb5\\\xb71\x07\x00\x00\x00\x00IEND\xaeB`\x82\xfb*9\xfd' )

def gettarBitmap():
    return wxBitmapFromImage(gettarImage())

def gettarImage():
    stream = cStringIO.StringIO(gettarData())
    return wxImageFromStream(stream)

def gettarIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(gettarBitmap())
    return icon

#----------------------------------------------------------------------
def gettgzData():
    return zlib.decompress(
'x\xda\x01\xd9\x02&\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02\x90IDATx\x9c\x85\x93\xbdO\x93Q\x14\x87\
\x9f\x97\xd6\x96"b\x8315j\x90jb\xd0\x9ah4Q\xe3g\x19tq\xd0Q\x19@\x1c:\xf7?p\
\x12\'\x07\'\x17\x17\x17]D11\xd2F\xa2\xed\xa0q0\xc1XM\xabQ)Q\xac\xd0\xa6T\
\xdf\xef\xde\xf7\xbd\xd7\x01Z@\x06\xcft\xce\xbd\xf7\xf7\xe4|\xdc\xa3E\xa3QZ\
\x96n\xa4U\xe9r\x89\xffY&\x93\xd1Z~\xb0\xe5L4&T\x8e\x1c\x00ccc\xebD\xdf>\x15\
\xb8{\xef\x01\x83\x83\x83\x00\xaa\x05\t\xb6\xc4gsg\xc9%smA<\x1e_\x03\xe8\xee\
\xeef\xeb\xb3)R\xa9T\xebHe2\x19-\x98n\xa4U\x8e\\[|\xeet\x8c\x97\x93\xb7y\xb9\
\xfc\xea\xca\xe8M"\x91\x08\xbd\xbd\xbd\x04\x02\x01\xa6\xa7\xa7\xdb\x90R\xa9\
\xa4\xb4V\x0fn\xdd\x18Q\x00\xc3#)&3O\xb9p\xf1\x1a\x8b\xb5"O\x1e\x8d\x03p\xe4\
\xe4(\xd9l\x96J\xa5\x82\x10\x82b\xb1H\xbd^G\x8bF\xa3\xdc\xba1\xa2\xb6\xc6\
\xb6\xafI\xb9\xe9i\x84\x82\xaa\x1dW\xe7\x7fr\xe5\xea\x18\xb5\xea<\x9f\x8b\
\x05\n\xef\x0b\xdc{\xf0p\xa9\x07\xa1\xce\x18\x17.^C\xd3"HQCI\x8f\xc9\xc9q\
\x0e\x1f>H\xf7\xc6\x10\x8eYcj\xea\x13\xef\xdf\xbd\xe5@"Ab\xdf\x00\x1dJB\x0b\
\x80\xb2\x91\xee\x02\xc2m\x10\xee\xd9\x8b\x12:\x00]\xa1&_\n/\x98)\x7f\xa0\
\xfc\xb5\xca\xce\xb8\x8e\xf2m\xc2\xe1\x00\xd2\xf9\xb52F\xcfk\xa2\x85\xfa\x08\
o\xd8\xce\xef\xb9\xe7\x10\xe8\xa2K\x9b\xe1\xed\xebit]\xc70L\x0c\xc7\x01\xd9\
\x04\xe9"\x85\xd3.-\x08 }\x07\xe7\xf7G\xccj\x1fJ\xf4\xa3\xcb9\xf0\x171\r\x13\
\xdd41L\x1b\xc7q\x91\x9e\xb3$\xf6-\xf0\xdd\x15\x80\x10M\x16*e6\n\x89e\xd7\tm\
\x9a\xc10l\xfeX6\x96\xed`\xd8\x16\xa6\xe9 =\x17\xbfi\x81\xe7\x80\xdf\\U\x82p\
\x08\x06\xaa\xd8Z\x054\x0b\xd7\xf31,\x8b\x1f\xe5:Z\xa7\x87n\x9a\xe8\xb6\rR =\
\x1b_\xb8 \x05\x00\xed\x7f\x90\x1a>\xa6\xce\'\x07\xe8\xdb\xb1\x19_\xb8<\x9e\
\x98\xa22\xaf#\x03\x02\xd9\xb1\x99=\xfd\'8s\xfc(\xcf\xce\x97\xd7\x8c[[\xbdL\
\xabA\xe3O\xf3\x00\xec\xdd}\x8a\xc4@\x82\xd8\x96\x1e\xb6\xc5\xb6pg\xff\x1b\
\xae\xe7\xae\x93O\xe6I\x92\\Y\xa661r\x08G\xc59r(B\xff\xae}\x84\xc3\x1d(a\xb3\
\xd8\xa8Q\xaf~\x07 \x9f\xcc\xe3\xdd\x7f\x05C\xac\x07\xcc\xce\xce\x92\xcdf\
\x97\xa3\xcc\xbf\xd7\\\xe2\x12I\x920\xb4\x14\xff\x05\xea\x8fF\xb0\xac?;\xa0\
\x00\x00\x00\x00IEND\xaeB`\x82z\x01I\x92' )

def gettgzBitmap():
    return wxBitmapFromImage(gettgzImage())

def gettgzImage():
    stream = cStringIO.StringIO(gettgzData())
    return wxImageFromStream(stream)

def gettgzIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(gettgzBitmap())
    return icon

#----------------------------------------------------------------------
def getvideoData():
    return zlib.decompress(
'x\xda\x01"\x03\xdd\xfc\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02\xd9IDATx\x9c\x85\xd3\x7fH\x94\x07\x18\xc0\
\xf1\xef\xfb\xc3\xcb\xf7\xee\xba^\xcf\xd9^\xad\x84b\xa5M\xeb\xd2\x82\x86Qd\
\x93\xcdV\x1a\xfd\x13\xcd\xc5\x84\x83\x84\xfaC\xc8\xc1\xa0 \xe6\x1f\x11\xb1\
\x7f\xd7\x1f\x11)$\x95\x15Q\x10\xb5\xdd$)\x83\x11\xe6\xa57\xb5\xf3\x8em\x12\
\xb994\x7f\x9e\xdd\xbd\xef\xbd\xf7\xde\xbd\xfbc\x9cK\x12\xf6\xfc\xf5<\x0f<\
\x1f\x1e\x1ex\x04UUy7jkkm\xfe\'\x02\x81\x80\x90\xcd\xe5o\x8e\xb9\xedb\xcd\
\xc5\xefo\xab\xd8\xbd\xefK\xc2\xe10\xf5\xf5\xf5\xef\r\x8dF\x87\xb8r\xb5\x93\
\xea\xeaj\x00;\x8b\xc8_\x1c(\xc3\xa1\xac\xa0\xd2\x9e\xe6\xf6\xcf\x9dl\xa9\
\xdcO,\x16\xc3\xe7\xf3-\x01\xdcn7\x05?>\xa2\xa9\xa9)\xdb\xb2\x03\x81\x80 \'u\
\x8b\xe9\x89yRf\x8a\x12-\xc9P\xffO\x88\xa2\x08\xb0\x04\xf1z\xbdH\x92\xc4\xc0\
\xc0\xc0"\x12\x89Dl96;\x8f\xcb\xad`\xc9\xeb\x88\x8e\xba9v$\x87k\xb7\x1fb\x18\
\x9f.A$I\xa2\xb0\xb0\x90\x8e\x8e\x0e\xda\xda\xda\x18\x19\x19\xf9\xb7\x7f\xe1\
BM\xab.\x15\xd3\xfd\x8b\xc0\xa9\x13\xb9\xe8q\x81\x1d\xe5\n\x8f\x1eG\xd1\x939\
\x88\xa2\x88\xa6i\x00TVT\xe0\xdbZ\xcej\xefJ\xd4\x95.~\x1d\x0e#\xf7Gw\xd2\xd7\
\x1b\xa4~\xf7\x04\xc1\x9ey\xa6f\x80\x8c\xc4\x1a\xc5\xe4i\xf7$\x86a,n\x92#\
\x0bxU\x0fe\x9bK\x11\xed\x0ct\xdeA\xfa{"\xd1\xba\xa7j\x1b\xe1\xde\x87D\xa2\
\x93\x8c\xfee\xf2\xfaM\x9a\xdf\xc6u\x16\x12q\x86_\xfe\x89(\x8a8d\x91\x82|\
\x0f\xe9\x94\x8e d\x18\x7f5HW\xcf\x0b\xe4P($\x00vMu\x03=\xbd?PT\xa0P\\$\xb1\
\xd6\xe9alJ\xa6\xf9\xe8\n\xda\xef\xdfGO\xc4\xb1\x8c\x18e\x9b7\x90I\x19\x8b\
\xc7\x95\x01\xb2\xc8\xe1\xba\x93l\xfc`\x00=\xbd\x8a\x07=\xb3\x9cm)\x81L\x86\
\xd3\'\xf39}\xfe\x1e\xba\x1e\xc7J\xc6(\xfd\xa8\x18\xd2\xc9\xff\x80,"\xcb\xb2\
\xed\xac\xfb\x84\xc1\xd0 -\xfeuL\x8eMa\x99&\x96\x95\xa2\xa5\xb1\x90s\x97\xee\
a$\xe2\xd4\xed\xab\x84\xb4\xb9\x14\x00\x08\x06\x83\x82eY\xf6g{?fan\x0c\xa7\
\xcb\x81\x92\x9f\x87\xe2Q\xc8u)\x9c\xf9\xb6\x88#\x8d71\x8c\x04\x87k|\xef\x03\
\x00\x9a\xa6\xd1\xf5$\x8c\xec(\xc7\xff\x95\x13Q\x10\xc1\xb6\t\rM\xd3z\xfe\
\x19]\xd7khl\xbe\x8b\x9dI/\x0f\x00\xb4\xb7\xb7\xe3\xf7\xfb1\xcd\x12\x0e\xeez\
\xcbpt\x81\xcb7\xfe\xe0\xf8!\'\xcf\x9e\xbe\xa4\xe1\xf3\x0f\xb9x\xeb\x16\x15\
\xdb\xf7 ,\xf7\x8d\xcd\'\xbe\x06\xe0\xccw\xdf\xb3\xbd\\\xa3\xaf\x7f\x88\xaa\
\xb2\x14sq\x8b\xb9D\n\xc3\xcc\xe0Q$\x9e\xf7\xcf,\x0fD"\x91\xc5ZUU^\xbf\x1ad\
\xeb&\t\xd5-\xb1^sR\xb4Z!/\xcfI\xae\xcb\xc1?<~$6?j\x94}\x00\x00\x00\x00IEND\
\xaeB`\x82K\x14\x801' )

def getvideoBitmap():
    return wxBitmapFromImage(getvideoImage())

def getvideoImage():
    stream = cStringIO.StringIO(getvideoData())
    return wxImageFromStream(stream)

def getvideoIcon():
    icon = wxEmptyIcon()
    icon.CopyFromBitmap(getvideoBitmap())
    return icon

#----------------------------------------------------------------------
def getfilefindData():
    return zlib.decompress(
'x\xda\x01\x9c\x02c\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02SIDATx\x9c\x85\x93\xbdOSQ\x18\xc6\x7f\xe7\
\xf4\xb6\x97\xf2a\x0fB\xbc\x84\xa0\t\x88\x82\x1fIY\x1c\xb1\xa5$\xc4\xc5\xc4\
\xd1\x89?Apqvqg!\xfe\x15\x8e\x9a\x98\x14(t@\x07Bq"Q\x08\x90R\xa4-mo)\xf4\xe3\
\xf6\xde\xe3b\x11\xa5\xc4\'y\x93w9\xbf<y\x9e\xf3\n\xa5\x14\x97eY\x96\x1e\x18\
\x18`ss\x13)\xa5\xe0?2ZK8<\xa1\x93\xc95\x96\xbf|%\xd8\x13"[,\x10y\xfcPG"Q\
\xb6\xb6R\xd7\x82d\xebqtz\x8a}\xbb\xcc\x8d\xc1A\nF\x80\xa3\xce\x10\x1f\xd2?\
\x89NO\x11\x0eO\xe8\xeb\x00B)\x85m\xdb\xfa\xe0\xb4\x8ci\x9aT\x1a.{\xb5\x06\
\xdf\xf2\x05vr\'<\x1f\xbf\xcbL\x7f/J\xa9\xb6.$\xc0\xc7\xed\x1f\x94=A\xa5\xe1\
Rnz\xd8M\x8d\x0e\x041\xa4de\xf7\x90\xcf\xdf\xf7p\x1c\xa7\xad\x0b\xc3\xb2,=\
\xdc\x1d$_\xab\xe1\xf8\xfc\x94]\x8fL\xcd\xe1\xa8\xe6Pt4\xf7\x02\x1e\xfd\xbd\
\n\xcf\xf3\xda\x87\x98N\xa7\xd9\xca\x17\xf1w\xf7\xb0\xdb\xf0\xd0\x86\x9f\x82\
\xeb\xb1S\xb6)\xd9E\x86:z\xd9\xcf\xe6\xa8V\xab\x98\xa6y\x15066\xc6\xcb\xf0#\
\x96Olr\xbbi\xea\xf5:u\xe9\xa3\x94\xcf\xe1\xd4\xaa\xc4F\x9f\x10\xeb\x0b]\x9f\
AGG\x90H$\xca\xea\xe2\x02\xcfF\x86\x18\xee\xed\xe1\xa6\xd7`\xe6V?o\xa7\x9f\
\xb2\xba\xb8\x00@\xa9Xl\x9b\x81\xf4\xf9|\xcc\xcd\xbd"\xb1\xb4B\xac/\xc4\x03\
\xbf\x8f\x17\xf7G\x18\xbd\xd1I\xac/Dbi\x05\xb4\x06!(\x95JW!\x91HToll\xe8\xf5\
\xf5u\x1d\x8f\xc7\xb5\x10B\x9b\xa6\xa9\x85\x10\xfa\xfd\xbb7\x9aDB\x03z~\xfe\
\xb5N&\x93\x1a\xd0J)Zc\x08!\x08\x85BX\x96\xc5\xf9\xf99k\xf1O\x9c\x9ed1\xdc*N\
\xfd\x9c;\xb3\xb3\x1c\x00\xa9T\n\x80d2\xc9\xe4\xe4\xa4neb\x00H)\xe9\xea\xea\
\xc2O\x93\xf1\xe1\xdb4\xfa\x834\xcf\nd\x0e3\x04\x02\x01\x94R"\x91X\xb9\xb0\
\x7f\x19rq\x0b\x9eSG7\xce0e\x13)]\x1c\xe1 \x9d*RJ\x80k!\x06@\xdd\xce\xb2}\
\xbc\x8b[\xab\xe0\xd5*\xb8\xbf\xc7\xabW\x10\xe2O{\xffB\x00D4:\xa5\x8f\x8e2\
\xed\x1a\xba\xd0\xf1\xf1\xf1_\x7f\xa0\xd5\x86RJ\xfc\x02\x9bT\x18<p\xd1\xfca\
\x00\x00\x00\x00IEND\xaeB`\x82\x08P0\xd6' )

def getfilefindBitmap():
    return wxBitmapFromImage(getfilefindImage())

def getfilefindImage():
    stream = cStringIO.StringIO(getfilefindData())
    return wxImageFromStream(stream)

#----------------------------------------------------------------------
def getproject_openData():
    return zlib.decompress(
'x\xda\x01\x10\x02\xef\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\
\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\
\x08\x08\x08\x08|\x08d\x88\x00\x00\x01\xc7IDATx\x9c\x8d\x91\xbf\x8b\x13Q\x14\
\x85\xbf\x9b\t\xc9F\x02\x19;\x1b!n%\x08\x8a\x906\xbd\xb0\xd8H\xa6\x89\xbb\
\x7f\x86\x8dE*\x11A\xec\xfd\x03\xb6H\xa3\x08\x82\x16\xa9l\xacDDX\xb4\x91\x80\
\x83\xa3DHf4;\x997\xf3^\xaeE~,\x8b\xc9\xee^x\xbc\xdb\x9c\xef\x9c\xf3\x9et\
\xbb]\xad\xd7\xebL&\x13\x1a\x9fop\x91In\x1e\xad\xf7\xb2\xe7y\xf4z=\xc20$\xf9\
X\x05\xa7\xa4\xd3\x8c\xbc0X-\x98\xfe=\xc69Gq\xecp\xd6bSK\xe7\xf1\x01Q\x14\
\xd1n\xb7)gYF\x18\x86\x00|}\xf7\x93R\x19\x14K\xf6g\x8eI3\xac\xb5\x14\xce\xe0\
l\x8e\xc9rT\nF\xa3\xd1:\x81\x04A\xa0\x9e\xe7\x01P\xf9p\xedB\x15\xf2\xd6\x10\
\x80~\xbf\x0fA\x10\xe8x<\xd6\xf3\xc7\xa9j\xa1\xaaFUg:\x1eG\nh\t \x8e\xe33\
\x1dE\x04\x11\x0f\x98"R\x05\xc6\xc4\xf1\xf7\xc5#\x9e\x17WDP\x9d\x02\x05"\x97\
W%\x00\x0b@\xe9\x9c\xb6\x1b\xc4\x00\xc5\xf2\x9c\x91@D\xd6\xbb\xea\x08\xd5\
\x1fK\xe7\x13\xf1V\x80\x88\x90\xbey\xc0\xce\x95\xabd\xbfB\xf6n\xdf\xda\x9aq\
\t\x98\x9f\x8a\r\xb0\xe3\xfbP\xbdD\xe7\xe1!\xb5fk\xb3\xfa\xd3\xeb\x15\xc02\
\x1c\x1e\xb1x\x98\x13X\xfe\xe5=\xb5f\x8b\'O\x9f\xd1h4H\x92\x848\x8e\xd7\xf7\
\x8bWK\xc0\xee\xee\xf5\x8d\x06\xf7\x1e\xbd\xa5\xf7\xfc%\xc6\x18\x92$\xc1\x18\
\x83s\x0e\xe7\x1c\x9dN\xb0\xa80\x18\x0c\xc4\xf7\xfdS\xc28\x8e5\x8f\xbeQk\xb6\
H\xd3\x14\x80\xd9l\x86s\x8e4M1\xc6\x00\xe0\xfb\xbel\xfd\x85\xfb\x87\xbf\xb9\
\xb3w\x97(\x8a\xa8T\xaax^\t\xe7\xe6\xe4\xb9a\x7f\xff\x00\xdf\xf7\x05\xe0?\
\xf7U\x82m\xe0\xd5\xac\x00\xff\x00Mq\n;!\rKl\x00\x00\x00\x00IEND\xaeB`\x82\
\x01{\xec\xb9' )

def getproject_openBitmap():
    return wxBitmapFromImage(getproject_openImage())

def getproject_openImage():
    stream = cStringIO.StringIO(getproject_openData())
    return wxImageFromStream(stream)

#----------------------------------------------------------------------
def getappData():
    return zlib.decompress(
'x\xda\xeb\x0c\xf0s\xe7\xe5\x92\xe2b``\xe0\xf5\xf4p\t\x02\xd2\x02 \xcc\xc1\
\x06$\xe5?\xffO\x04R,\xc5N\x9e!\x1c@P\xc3\x91\xd2\x01\xe4_\xf0tq\x0c\xa9\x98\
35\xf8\xa4\xe0\x11\x05\x9e\xc9\xe5A\r\xd6\\K\x97\x9a,U\xb6\xba`\xc7c\xc9s\
\xf2MV[\xbb\xbe\xa7\xca\xb1;\xb2\xc6W\xa2X\x19\xde\xe5]nk;\x1f=Q%k\xed\xab\
\x14\xe3\x88\xf2\t\xa2\xe7\x17\xdaI\xbbmZ<\xbby\x8d\xc6J\xde(\xe5K/N\xdc\xbd\
\x18\xe3\xc2~\xc5\xef\x88\xac\xad\xda\xca\xdc\xdb,\x0e\xef\xfa\x9e\xber\x10:\
\xb3\xeb\xb0\xc0\xcb\xc2\x82\x07A\xfcw8\xd2zU\x1c\x85\xd2\xd8&9\xd7V\xfe:\
\xe4\xdf%9_\xed\xf3\r\x9d\x97\n\xb3\x15\xd7\x05\x9cr\xf8dfb1ADeiCo\xc6\xfd\
\xef/\x1d\xce\xe9\xdb\xfe<=\xd7[\x93\xa1\xa0\x83\xe1y\x9b\xcc\xc9\xd2\xd8\
\xfc\xfa\x07\xb3NG\xbfzg\xa6#t2\xd93mg\x8d\xce\xfec7\xb5k\xaag2\x1f\xdc\xff\
\x83)\xa7v\xd1\xe6\x0cI6\t\xa0\xdf\x18<]\xfd\\\xd69%4\x01\x00\x0e\xadp\x02' )

def getappBitmap():
    return wxBitmapFromImage(getappImage())

def getappImage():
    stream = cStringIO.StringIO(getappData())
    return wxImageFromStream(stream)

#----------------------------------------------------------------------
def getbookmark_Data():
    return zlib.decompress(
'x\xda\x01\xb3\x02L\xfd\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\
\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\
\x08\x08\x08|\x08d\x88\x00\x00\x02jIDATx\x9c\x8d\x92OH\x93q\x18\xc7?\xcbw\r\
\xd7\x18\xef\x1c\x89\xc5\xa4\xc0\xc3@d\xe8\xf0\x12\x82\x1eb\xa3C\xa0\x15\x94\
Q\xe2\xa1S\x1d\xfa#\xd4)\xe8\xd01L\x8a\xc0(\xdaa\xed\xe8B\xc4\x0e60\xb06W8\
\x8b\xb5"\xdfHQg\xd3\x83\xcb\xbd\x9b\xd6\xb6w\xfe:\xd8\xe6\x9c\x06}\xe19}\
\xf9~\xe0\xfb<\x8fN\x96e\xca\xa5\xaa\xaap\xbb\xdd\x84\xc3a\x1d{hmmM\xc8\xb2\
\\\xf2\xa4rS\x92$\xb1\xb0\xb0\x80^\xaf\xa7\xb7\xb7W\x00$\x12\t\xe6\xe7\xe7u\
\xc5\xf0.\xa2,\xcb\xa5\x01\x84\x10B\xa4\xd3\xaaH&\x93"\x1e\x8f\x8bx<.\xba\
\xba\xba\x04 \x14E\x11\x80(\xcfH\xbb\x88\x7f\xa5\xd7o[\xc3\xc3\xc3(\x8aB$\
\x12)\xd5(z:\xda.\n\xbd\xa3\x9d|t\x02\x00\xf1\xf69\x99L\x9aTJ\x05\xc0f\xb3\
\x11\x8b\xc5\x98\x9a\x9a\xc2`0\x00\x10\x08\x04\xf0x<\xc8\xb2\xac\x93\x00\x1e\
\\\xbf@kM\x0f\xd1\xf9\x15\xf6_yZ\x82\x11\xf4\x11\x0c\x06\x19\x1b\x1b\xc3j\
\xb5\x92\xcdf\x19\x1f\x1f\xc7\xeb\xf52\x1d\x89p\xa3\xafOH\x00\xde9\x95\xd7+U\
\x1c\xc9\xfcd\xf0\x92\x9b\x96\xba3|XNs\xf9Y;m\xb7\x06\x01\xe8?\xddB(\x14\xc2\
\xef\xf73\x1d\x89\x10\x8dNo-^\xfe<\xaa\x0b\xdfE\x84\xaf\xde\xc3\xfam\x0e\x98\
\xe3\xa4\xfd0\x07\x0f\x18*`\xaf\xc8/W\x97\xc25\x96\x9a\x8a3~ZBZZ\xa4\xcah$\
\x90X%{\xc8\xba\'\xccy\xee\x1a#7Oa\xab?Z\x06\x08\xfa\xd8\x08<\x01\x1ay<\xfa\
\x06\xdf\xe4\x0c?f\xe3\xec\xab\xae\xde\x05+j=\x93\xda\xbaB\xf1\x13\x9dN\xa7\
\x18\x1a\x1aB\xd34~\xfd\xce\x82\xd8\xc4\xff\xee+\xbe\xc9\x19\x16\x93\x05\xf4\
&\x13\x00\xb5Ui>\x86&\x18\xb9\xddC\xff\xc0\xc3\xed\n\x99L\x86Tj\x8b*\x84\xa0\
P(p\xa2\xa9\x9e\xe3\xf6:\xf2\xf9<\x13\xb3\xab\x0cDS$\x966@2\x90\xd9X\xdf\xb9\
\x03EQt\r\r\r\xa2\xb5\xb5\x15\xa7\xd3Iww7f\xb3\x19M\xd3\xd04\rg\xad\x01O\x87\
\x05\xb0\xe0\xba\xf3\x9e\\6\xbb\xb3B\xa5TU\x15\xcd\xcd\xcd8\x1c\x0e:;;1\x99L\
\xe4r9\xf2\xf9<\xb9\\\x8e\xb3\xf7_\xd0aH\xfc\x1bP\tkjj\xa2\xb1\xb1\x11\x97\
\xcb\x85\xd1h\xe4\xfc\xa3\x97\x1c\xdb\xfc\xfe\x7f\x80J\x98\xddn\xc7j1\x13\
\xfb2\xa3\xfb\x03w\xe8(\xdb`h<!\x00\x00\x00\x00IEND\xaeB`\x82\xc1o4\xd0' )

def getbookmark_Bitmap():
    return wxBitmapFromImage(getbookmark_Image())

def getbookmark_Image():
    stream = cStringIO.StringIO(getbookmark_Data())
    return wxImageFromStream(stream)

