# -*- coding: utf-8 -*-
#------------------------------------------------------------
# This file was generated by encode_bitmaps_filename.py
#  
# where filename is the name of your file e.g
#                            encode_bitmaps_myproject.py
# All your images will be added after the code below
# You should rename your image file eg to images_myproject.py
# before you add the images
#------------------------------------------------------------
import wx

import cPickle, zlib
#----------------------------------------------------------------------
def getbranch_addData():
    return cPickle.loads(zlib.decompress(
'x\xda\x9d\xd01\x0f\x83 \x10\x05\xe0\xdd_\xf1\x92\x0et\xba\xc0\xd0\xc6\xb9M\
\x18\xcb\xe0\xc2j\x8cSM\xaf\xff\x7f\xeaq\x80J\xec\xe4\x0b\xcb\xfb8\xc0x]\xbe\
\xae\x1b\x8c\xbbC\xd6\r\xcet\xe3`\x80\t\x8fe\x9c\xde\xdaX\xda\xc5\xf7\xfei\
\xadv\x92\xfe\xe2\xcf\xac%\xd4M\xdfk\x8f\xb9[[\x86Am\xca\r\xb4y\xacH\xf8\x83\
H\xa8\x1b1\xa5LJ\xc0\x8c\xf6x2@u\x87\x02!d\xdd\x1eJ\xb6jy([\xd5:\x19J@\r\xca\
g\xe1\x88\xcc\xe7q\xcd\x0e\x0f\xbf\x8e~\x9b\x9b[\x9f' ))

def getbranch_addBitmap():
    return wx.BitmapFromXPMData(getbranch_addData())

def getbranch_addImage():
    return wx.ImageFromBitmap(getbranch_addBitmap())

#----------------------------------------------------------------------
def getcutData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"c\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0\
/\x02\xc8S6\x00\x02s\x0b0_\x01\xc8\xf7\xcb\xcfK\x85rP\x01BP\x0f\x8a\xc9\x15\
\xd4\x03!4A\xa02=\x05LA=,\x82p\x85\xc8\x82\x11z\x11X\x04\x15"""P\x05A\x02\
\x11 \x19$A0\x9fxA\x05L3\xb1\x85\x12j\xd0\xe9\x01\x00\xd3\x83E\xa4' ))

def getcutBitmap():
    return wx.BitmapFromXPMData(getcutData())

def getcutImage():
    return wx.ImageFromBitmap(getcutBitmap())

#----------------------------------------------------------------------
def getdoctorData():
    return cPickle.loads(zlib.decompress(
'x\xdaU\x94\xcbR\xea@\x10\x86\xf7>E\xaa\x86\xc4S(\xa9!\t\xb9\x88X!#\xec$\x0b\
\xab\xac\x94;\xae\x82 \x10\x14\x10\x9e\xfeLOw\x07L\xb3\xe0\xeb\xdbt\xff\x13\
\xf8\xb7\xda6o^o\x9b\xa1\xa5?\xa1\xb4\x9a\xb77\xc3\xd7\xdb\xc0\x1a[\xd9j8^\
\x1a\xfa\xd2$B\xd9RR\x1a~D\x0e%\xf1\x82\xe3\x1er\x0b\xd8\x97`\x86c\xce\xa7\
\xf8\x80\xf3\xfd\xd8\xf0\xd1\xe4\xc7R\x12\x0f\x81{2Q!\xe6\x87\\O\xdc\x04VR1G\
\xc0Q\x1c\xa9\x08\xeb\xcf\xc0\x9e\x9e\x8e\xce\xab\x03\'\x12\xcc\xb0\x04\xee\
\xc6\xdd\xa0\x8b\xf9.\xb1"\xce\xb9\xbf\xc2\xfc\x948 ^\x03\xc7\x97y\x0e\xc0}\
\xd9S}\xe4%\x9e\xef\xb1>\xdf8\x7f\xac\xcd\xb0\x02\x0et4@\x9e\xe2\xfe>\xeb\
\xfb\x84\xfb?3\xff\x00gz?\xd2g\xc6\xf9\xc4m\x9c\'\xe6~s\xe0\x96\x043<\xe68\
\xcd[0\xd3<\xbe\xe9/3\x19!\xbf\x18\xbd\xe2$H\xb0\xff;\xce\xeb\xb1\x9e\x1f\
\xa8G\x8b\xefg\xc3\xf5\x19\xb2\xc7\xf3gX\xff\x89\xfbw\xb5\x19\xde\xe2}e\x01\
\xc5k\x9c\xdf\xc3x\x07\x19\xcc\xb0\xa5y\xb0YO\r\x08#v\xdcW},~\xc0\xe1\x02\
\x16;\xc3\xc3<\x16#1\x97\xab\x8f\xa6\xf8\x1b\xe7\xd32%\x0eS\x899\xe28\xd5\
\xef\xf0\xbc\xea\xe5\xda\xe3\xe5V\xcb\x9fP\x8cJ\xcc\x89\xe9\'#\x16\xf3\x9e\
\xcf\xa7\xf8/\xce\xe7\xf3\x8f\xc5\xe68\x89s\x87\x97]\x89\xb3\xe2|:\xafAq\x16\
\xd7\x01~\x96`$\x96~\xdcb\x93\xe7\xf9]\xaa\xbfVN\xb7\xc8\x05<\xb5\xf4\xcaY\
\xd8\x8eq\n;\xad\x9ciQ\xdft\x84h\xb4\xdb\x8e[9];\x87\x96\x0fO\xe2\xbe~q\x169\
\x94?6=\xdf\xbe8\x83V\x185D#N\xf4\xdfI\xe5,\x8f\xd3\xddO\t\xcf\xa5\xa7u*\xa7\
\xc7r\xbf/\x17\xfb\xed\xd5\x9c\x8ba\xf9=\x99}\xccg\x9f\x17\xa7u:\x95\xcb\xd5\
\xf9\xf7<N\xaf\x9d\xbby~\x10\xb5\xdc\xbd\xda\xc8j\xefF\x8e\xd3\xa9\x17\xd7\
\xbb[\xeb\xaf\xd1At\xec\x97?\x82\x0c\xb2\xb7\x89p\x8a?*\xe5\xa21P\xefK\xf0\
\x81\xd3\xfd\x0f(f\x1c\xb5' ))

def getdoctorBitmap():
    return wx.BitmapFromXPMData(getdoctorData())

def getdoctorImage():
    return wx.ImageFromBitmap(getdoctorBitmap())

#----------------------------------------------------------------------
def getdrbagData():
    return cPickle.loads(zlib.decompress(
"x\xda]\xd2\xcfo\x820\x14\x07\xf0\xbb\x7f\x05\t\xa8K\x05R\xa0\xd0\xa2b\x84*\
\xc7\xf5\xe0\xc5\xeb\xb2x[\xc60&\xfe\xfb\xeb\xfb!\xba\xbdg\xd0\xcf\xf7\x01\
\x96\x86\xb7\xaf\x9flvZfU\xe0?\x85\n\xb2\xe5\xec\xe3\xb4T\xc1g\x10\x16\x12\
\x1a}e+v\x01\xaedi+rL\x86F\xdf\xc0\xdah\xa5\r:a[\xf6\x16\\Kh\xf4\x05\xdc\x9a\
V\xb547\xe0\xdet\xb6#\xa7<\xb7<w`+\xa1\xd1\r[\xb1\x07\xbc^\x1emO\xbe\xd3\xfd\
\n[\xd0\xf5\x0bp)\xa1\xd1\x92\xad\xd8\x11>\x8f\xa9lE\xe7\xd7`#\xa1\xd1\x1bp'\
\xa1\xd1\x15\xf8(\x0f\xf6H^\x93\xa1\xd1\x81\xf7\xfb\xf0}A\xe4\xb4\x98\xde\
\xf6ts\x01V\x12\x1a\xadi>mV\x88\x9b'\xa1\xd1{\\\x8c1\xca\xd0|\x8e\x9b#k\xdb\
\xd2|G\x86F\x9fq\xb1\xa6S\xbc\x99\x19\xcf\x15\xcfG\xfa?\xe9\x0b]\xf2\xf9\x8f\
\xcd_\x81\x0f\x12\x9a\x1f\xc6W\n\x85\xbf\x82)<\x0f\xce\xb9\xd5\xfeo\xe8\xc2(\
\x8a\xe6\x8b\x7f\xa1h\xd2&\x11\xafa\xe3\xdc\xc6\xad\x17\xfe\x0e\xcd3\xdc\xf9\
r\xbb\xd8\x1f\xb7\xd9#<\xe7y^$\xaa\xcc\xf3!\x14\x19\x85\xa9\xcf\xf2*\t\xe1k#\
bz\x89\x1d(\xd7\x06\x8ek\xc1o\x1a\x85\xa3\xe6PL\xa1\x1e}a\x18?C\xa3\xc7\xbb\
\xfe\x1f>.w\xa2\x8e\xe8\xed]O\xe5\xea\xfa\xca\xeb\xbc\x89g\xc9\x97g\x7f-\x1f\
\xa6\xbf\xcba\xbb\x17" ))

def getdrbagBitmap():
    return wx.BitmapFromXPMData(getdrbagData())

def getdrbagImage():
    return wx.ImageFromBitmap(getdrbagBitmap())

#----------------------------------------------------------------------
def getearthData():
    return cPickle.loads(zlib.decompress(
"x\xdaM\x921o\xc20\x10\x85w~\x85\xa5pP]bd'\xc1q\x08X\xa1\x91\x18\xcb\xc0\xc2\
ZU\xdd\xaa\xba\xff\x7f\xaa\xed\xbb\x03\x9c\x0c\xf9\xde{v\xee.y\xfb\xf9\xb3\
\xab\xdb\xd6:\x95\xeevTv\xbb\xfa\xbcm\x07\xf5\xa5*\x93\xd6\xe0\x0bGao\n\xaf\
\x89\xdf\x17Cl2w\xa6\xeb\x07\xe2\xbd\xf8\x1d\xed\x9fd\xffB\xfeQ\xfc\x9ex\xcc\
|\xf6\xe7\xfeLyM\xfeb\xd8\xdf\xb1\xef\xd9G9\xefB|%\xee%\xdf\x94z|\xe7\xb9\
\xfe>\xb3\xf3nq\xc4@\xf9\x8b\xd4\xdf\xc9~\xeeoC\xdc-\xef\x94\xf7\xc2\\\x7f\
\x90<\xb3J\xfc\x11\x7f\xbf\x0b\x1c\xe8\xe5C\xcf\xcd;\n{\xc3/\xbbg\x1e\x8c[xX\
\x15\xe7=\xe7k\xf2\xf3U\xb8\xa5\xfd\xc3\xc2\xcd\x9c\x84\xb9X+\xe73\xcfeX&\rS\
\x8aSjw\x8f\xd7\x18\xeb9?\x8bX\xada\x83'\x8d\xd3\xe1)V\x00\x10\x02hD8\x88\
\xd8\x1c\xa1,\x8b\xd8&\x95>\xc8dI\x0c\x88\x18\xba\x99\xa6\x9c|\x80=\x00f\x11\
j\xfau\x105\xd8\x10tNZp\xf4\x7fe\xdf\xe6T\x8e\x1e\x9d$S\xc2\x16)\xad\x17\x11\
[\xedmy\x884!JH\x01wj{z\x8a-N#\x17\xff\x88\xa6\x03\x1ai\xd3\xb0\xba\xcf\xdac\
 M9A\xdb\xa9y\x99\x92\x9a\xeb\x18\x87\xd8\x8f<\xba\xdd?_s\xa2|" ))

def getearthBitmap():
    return wx.BitmapFromXPMData(getearthData())

def getearthImage():
    return wx.ImageFromBitmap(getearthBitmap())

#----------------------------------------------------------------------
def getsendemailData():
    return cPickle.loads(zlib.decompress(
'x\xda}\x90\xb1\n\xc2@\x0c\x86w\x9f"p\xb5\x95\x06\x82u\xb0\x1d\x83BG3\xb8\
\xdc*\xe2\xa4x\xbe\xffd\xeer\xbdV\x05\x7f:\xf4\xfb\x92\xcbq\xd9<^\xdd\xea\
\xdct{\x88\xdf\x0e\xbafu97\x0e\xaepx\\\xae\xf7D\xa8\xe4\xb6\x9a~HL\x91\xfb\
\xa1?f\xe6\xa9>\x1a\xb7V\x8f&q\x15y\x1c\xc6c\xe6\xf5T\xcf\xe7A\xf9\x14\x9e\
\xb7\x04~j\xce\xc3\x82\r/,\xc6\xe5\xf2\xda\xfa\xcbe\x90B>\x04\xfb\x9b\xa5:AZ\
J\x06Q\x07\x84\xb3$b\x16\xcf\x94\xe3Lz\x16\xe1j\xcaB\xa2\x99u]$\xc6$Y\xb7Ej\
\xaa\x9f\xe3K7KC\x1d\xad\xb3\xb3,M\x1c\xc2\x7f\xe9r\xd8\x07D\xe7\xe6\xb7\xeb\
\xbb\x99\xbc\x00~,\x04\x85H\xbe\xb6\x04\x88,eu\xf4\x06\xce5ld' ))

def getsendemailBitmap():
    return wx.BitmapFromXPMData(getsendemailData())

def getsendemailImage():
    return wx.ImageFromBitmap(getsendemailBitmap())

#----------------------------------------------------------------------
def getemployeesData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"#\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0\
O\x01\xc8\xf3\xcb\xcfK\x85r\xf4\xf4\x14\x80\x84\x02\x94\x01\x11\xd4\xd3\x03q\
@\x08\xcc\xc0\xad\x12\xc4\x00\n\xe9)@\x19\x10A0\x00\tB\x18\xc4\x08*\x80)\xa8\
\x990!dAl\xda\xb1\xbb\x13&H\xbcJ\xec~\'(\x88\x19 z\x00\xc7fCp' ))

def getemployeesBitmap():
    return wx.BitmapFromXPMData(getemployeesData())

def getemployeesImage():
    return wx.ImageFromBitmap(getemployeesBitmap())

#----------------------------------------------------------------------
def getfind_globalData():
    return cPickle.loads(zlib.decompress(
'x\xdam\x8e\xb1\n\xc30\x0cD\xf7|\x85\xa1\x83\x0b\x02\xd3,\xb5g\x1b2\xc6C\x96\
\xac!tj\xa8\xfa\xffSeYv\x1c\xd3CH\xdc\xf9I\xf8~|\xc7a\xd1\xe3SQQ\xd3\xc3\xb6\
hP\xbb\xf2\xc7\xb6\xbf\xd9)r\xb7\x07\xc9:\xf61y\xebl\x10o\xc8\xcf\xf8y\xb1\
\xc1\xf48\xb9)L\xf9qM\xde;\x1f\xbc\x93c\xa7\x0c)\x87\xab\xaau\x86\x7fI\xacj\
\xc3\x18\xa5:\x12\x00\xb8]H@\x88\x91ZO\xb2Z\x128\xcd\xfb\x95dH\xd0\xf2O\x86L\
\xc6sHg\xe4`\x17\xa2\xacc\x17\x9a2\xdbuSf\t/\xa2\xd0\xfc\x00\xfanaA' ))

def getfind_globalBitmap():
    return wx.BitmapFromXPMData(getfind_globalData())

def getfind_globalImage():
    return wx.ImageFromBitmap(getfind_globalBitmap())

#----------------------------------------------------------------------
def getfind_specificData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"c\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0\
O\x01\xc8\xf3\xcb\xcfK\x05s"\x80\x1ce7\x0b7g7\x0b\xa8$*\x80\x0b\xea\xe9\xe9\
\xc1I\x84`\x84\x1e\x9c\xc4\xabR\x0f\x04\xa0$B0\x02,\x18\x81,\xa8\x87\x0c\xa0\
\x82zP\x85`JO\x8f\xa0\xa0\x1e\xba \x92\xedpA\x88\xad0W\xe0\x13\xd4\x83\x0b"\
\xb4\xe3\n%4A=\x00\xc7\x83Il' ))

def getfind_specificBitmap():
    return wx.BitmapFromXPMData(getfind_specificData())

def getfind_specificImage():
    return wx.ImageFromBitmap(getfind_specificBitmap())

#----------------------------------------------------------------------
def getgeneralpracticesData():
    return cPickle.loads(zlib.decompress(
'x\xdae\x90\xb1\x0e\xc20\x0cD\xf7~\x85%\x86"U:\xa5\x0b\xed\xceN\x87.Y\x11bC\
\x98\xff\x9f8\xdbu(p\x8a\x12\xdd\xb3/N{|\xbc\xc6n\xed\xc7\x93pq\xeb\xbb\xeb\
\xdaW\xb9\xc9a\x9a\xa7s)\xee\xd5|\xa1\xa6\xd9=\xb2\xbe\xf9%|\xab\x0b\xfdE\
\x9fw7C\x84[\xb3P\xe0\xaa\x95\x07\xb7\x84\x08U\x16\xd0`\xf4n\xdb\x0eZ\x9e\
\x89\xfa\x03\x99\x84U\xfe:\xf7\x83\x92\xda\x9c\x80\x8a\xcc/K\xbbS\x81\xe0\
\x1eOHE\xdc\x94\xd3\x93\xa9+!6f\xdf\xa4\x08\x08\r&\x16\xfe@\xb5\xa8\xf8\xe3\
\x13\xfam\xf4C\xf4\x7f?~\xa0\xe0\x7f\to\x0bS\\+' ))

def getgeneralpracticesBitmap():
    return wx.BitmapFromXPMData(getgeneralpracticesData())

def getgeneralpracticesImage():
    return wx.ImageFromBitmap(getgeneralpracticesBitmap())

#----------------------------------------------------------------------
def gethelpData():
    return cPickle.loads(zlib.decompress(
"x\xdam\x90\xb1\n\x830\x10@w\xbf\xe2\xa0\x83\x05\xe1\xd0\xa5\xc9xDp\xec\r.YE\
:Uz\xfd\xff\xa9\x97xV\x1b{\x98\xe1=\x1f\x87\xf1\xba\xbc\xbbj\xac\xbb\x1b\xe8\
\xe3\xa0\xab\xabi\xac\x11f\x08\xcb4?3\x91\xd2\xa5\xd5q>3'v\xde\xf5\xc6\x92x\
\xf0C\xdf\xb6\x99A\xf9.\xafG\x86\xb8\xbd\x1c\xd6\xb8I\x1c|\xe8\x83\xb7\x18p\
\x1f\x00\x93\x18c\x14;\xb8K\xf9j\xe4C\xd9\x90N\x13\x8fR\"\x91\xa8/Jb=T\x94\
\xba\x8f\x89\x8bR\"\xa7\x95e\x99\x16\x9cJ\xfb\xce\xa2\xa4?\xa5\xfc\x96\xdb\
\xddU!o\xd7\x04\xe0<(\xeavi\x93~\xd2I\x82I\xfc\x00\xc4\xe0n\t" ))

def gethelpBitmap():
    return wx.BitmapFromXPMData(gethelpData())

def gethelpImage():
    return wx.ImageFromBitmap(gethelpBitmap())

#----------------------------------------------------------------------
def getlighteningData():
    return cPickle.loads(zlib.decompress(
'x\xdau\xd01\x0e\xc20\x0c\x05\xd0\xbd\xa7\xb0\xc4\x10\xa6\xa8\x19\xa0\x99A\
\xca\x88\x87.Y\xab\x8a\x89\ns\xff\t\xc7m\xb0=\xf0\x95\xe5?Kq\x94\xf3\xf6I\
\xc3\x1c\xd2\x15\xf8\\ \x85a\x99C\x84\x15n\xdb\xb2\xbe\xa4\x11\xb7\xd3\x94\
\xa7\xfb8J\xc7\xd6K.\xbd\x03\xf7\x07\xbd\x9fRj\x1f\x96|\x0c},FIu\x18\x89\xd3\
\xcc`$D\x14S4\xf6\xc3\xddZ\x14\xc5\xd0\xdf\xb9\xef%\x7fg\xe5\xa8\xf9\xed\x87\
\xb9\xed\xdd\x0c\xaa\xe9\x93\x8c)\x1aS\xac\x7f~\xc9b\xfc\x02\xdd\x11U\x0c' ))

def getlighteningBitmap():
    return wx.BitmapFromXPMData(getlighteningData())

def getlighteningImage():
    return wx.ImageFromBitmap(getlighteningBitmap())

#----------------------------------------------------------------------
def getpadlock_closedData():
    return cPickle.loads(zlib.decompress(
'x\xda\x85\x90\xb1\n\x03!\x10D\xfb\xfb\n!\x85\xa9\x06,\x12\xad\x15,cq\x8d\
\xedq\xa4\xca\x91\xcd\xffWY5\xcazMFY\x98\xb7\xc3*{=>fY\xb5\xb9+\xbe7e\xf4\
\xb2\xad\x1ajW\xfe\xd8\xf6Wu\x89\xdd\xc5:\x1b\xac\xab^\xb1\x7f\xd0\xfbYM.\
\xcd\xe8b\x88\xadI\xc5{\xe7\x83\xef\xe1Y\x02\x82u\x86\xc8,\xcc\x10\x99\x00jT\
@\x8e\xe2\x0c\xa9\xcc\xa4:\xb7\xc3\xe2\x89Ja\xfa\x83\x0c\x9a\x90\x06\x84P\
\x1a0S?\x02\xa6!\x01G0\xffK\x8a\x99\xe3\x9f\xf2\xf5yK\xd3\xea\xf0\x05\xeaN^\
\xe5' ))

def getpadlock_closedBitmap():
    return wx.BitmapFromXPMData(getpadlock_closedData())

def getpadlock_closedImage():
    return wx.ImageFromBitmap(getpadlock_closedBitmap())

#----------------------------------------------------------------------
def getorganisation_addData():
    return cPickle.loads(zlib.decompress(
'x\xda\xad\xd0\xb1\x0e\xc20\x0c\x04\xd0\xbd_a\x89!LQ2\x80:\x83\x94\x91\x0c]n\
\xad*&*\xcc\xffO\xb8Nk\\u\xe5\xe4\xe5^n\xcay\xfe\xe4n\x08\xf9Jr\x17\xca\xa1\
\x1b\x87\x00\x9a\xe86\x8f\xd3K\x1bK;\x95\xbe\xdcS\xd2N\xd2\x1f\xfc~j\xa9\xdb\
c\xe9\xb5\xc7\xd6S\xb2\xb1K$\xf2\x08\x1c\x11\xcc\xa0\xb8\xe4\x87`\xc8\xed\
\x97\x02\xb5.\xeaP\xad\xa9\xe1j\xab64k\xba-\xab\x05\xe4\x11\x92#2\xff\x17]\
\xf6\xbfd\x11\x8c_\x1azek' ))

def getorganisation_addBitmap():
    return wx.BitmapFromXPMData(getorganisation_addData())

def getorganisation_addImage():
    return wx.ImageFromBitmap(getorganisation_addBitmap())

#----------------------------------------------------------------------
def getorganisationData():
    return cPickle.loads(zlib.decompress(
"x\xda\xad\xd01\x0b\x83@\x0c\x05\xe0\xdd_\x11\xe8p\x9d\x1e\x1e\x888[\xb8\xb1\
\x8bKV\x11'\xa5\xf1\xffO\x8d\xf1\xb4\xb9v\xed#\x1c\xbc/7\xe5\xben\xb1\x1aBlI\
\xa7\xa1\x18\xaaq\x08\xa0\x89\xfau\x9c\x16k\xac\xed\x96\xba\xf4\xa8k\xeb\xa4\
\xfd)\xaf\xd9\x8a\x9c\xcb\xd4\xe5e\x19\x8f\xc0\xfe\x94\x08f|#\x18:%*\x88\xec\
\x0b\x87f\xa6\x1f\xcc\x96\xf5\xc0\xcb\x0e=\x7f\xca\x15\x90Gh~\x91\xf9\xbf\
\xe8R^\xc9\x9f\x0eo~0]\xa1" ))

def getorganisationBitmap():
    return wx.BitmapFromXPMData(getorganisationData())

def getorganisationImage():
    return wx.ImageFromBitmap(getorganisationBitmap())

#----------------------------------------------------------------------
def getpadlock_unlockedData():
    return cPickle.loads(zlib.decompress(
'x\xda\x85\x8f=\x0b\xc3 \x10\x86\xf7\xfc\n\xa1\x83\x85\x83\x17\xb3\x04\xe7\
\x06\x1c\x9b!\x8bk\x08\x99\x1az\xfd\xffS\xef\xb4\x1a[\x02}/\x88\xcf\xe3\xf9\
\x91\xeb\xfe\xea\xbb\xd9\xf6\x83\x91O\x06\xdb-\xb3\x85Y\xcdm_\xd6G"\x16\xba\
\x8cN+\xf1\xa4\x1c|\x18]fR\xf6N+\xb1\x11\xbe\xf3sK\x10Ks\xf0\x9fE\r$yvHD\t\
\xbe%"\x03\x9c\xed!\x19\xba\xf2#q"\'\xc9Y\xa7\x84\xd3\x86"AD\xcc\xd0B\x91`\
\x16\'\x01U\x89&Te\xe4R\x8d\xa4\x9aF\xd6\xc6\xf8\xaf\xb39\xb3\xbe\xb3\xbd=\
\xff\x11\xdeR\x1e^\xc8' ))

def getpadlock_unlockedBitmap():
    return wx.BitmapFromXPMData(getpadlock_unlockedData())

def getpadlock_unlockedImage():
    return wx.ImageFromBitmap(getpadlock_unlockedBitmap())

#----------------------------------------------------------------------
def getperson_addData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"c\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0\
O\x01\xc8\xf3\xcb\xcfK\x05s"\x80\x1ce7\x0b\x03 \x80J*\xe8\xe9\xe9)\x80A\x04\
\x10\x13#\x18\x01\x020A\x90\x88\x1e\x9aJ=\x08@\x13\x04k\x87\x9aJ%A\x05\xb8=\
\xe4\t* \x99H\rA=\x00\x86PD\x9b' ))

def getperson_addBitmap():
    return wx.BitmapFromXPMData(getperson_addData())

def getperson_addImage():
    return wx.ImageFromBitmap(getperson_addBitmap())

#----------------------------------------------------------------------
def getpersonData():
    return cPickle.loads(zlib.decompress(
"x\xda\x9d\x8f\xb1\x0e\x02!\x0c\x86\xf7{\x8a&\x0e85\x10Nr+\xba\xdb\xe1\x96\
\xae\x97\x8b\x93\x17\xeb\xfbO\xb6\xa8\x89\x96\xc1D\xc2\xc0\xf7\x15\xda\x9f\
\xfdvO\xc3\x1cR\x01\xdd\x07HaX\xe6\xc0\xb0\xc2q[\xd6k#Q\xda\xe5\x98\xc7\x1c\
\x1b\x93q\x99\xca\xa9L\x8dA\xf9,\xb7K\x03\xb4b\x8du\xac\xf1U\xb4\x85,\xcf\
\x03|Hf\xa6N\n3zI@\x88\xf8-I\x1f\xeb]'\xd5\xb0xi\x16;i\x91:i\x91\xd8O\xb7\
\x9en\xba\xc5|\x07\xfd!\xadk\xff\xf7?%>\x00wOVH" ))

def getpersonBitmap():
    return wx.BitmapFromXPMData(getpersonData())

def getpersonImage():
    return wx.ImageFromBitmap(getpersonBitmap())

#----------------------------------------------------------------------
def getprinterData():
    return cPickle.loads(zlib.decompress(
'x\xdaU\x90=\x0b\xc3 \x10\x86\xf7\xfc\n\xa1\x83\x05\xe1H\x96\xea\xac\x901\
\x0eY\xb2\x86\xd0\xa9\xa1\xd7\xff?U\xcf\xaf\xbb\xd7\x10x\x9f<\xf1\xc4\xe7\
\xfd[\xa6]//\x95\x9e\xf4\xd2\xd3\xb9kP\x97\xf2\xf7y}\xa8\xc5\xd4\x1e\xd6\xd9\
`\x1du\x93\xfb\xea\xd60\xcf\xd4U\xea\x1b~\xdfT\x8e\xf6q-2\xe6\xee\x9d\x0f\
\xdeUYf@ha\x10\x8e\x1a\tI\xcb\xacC.2X\xc5\xbci\x85C\xc4\xb4\n\xec\x93\x89\
\x15\x08\xd83L\xe0A\x14f\x8c\x91T\xc5\xa11&\xc16]\xfe\xde\x8e\x04|P?<3\xc5-\
\xc9\xab\x83?\x06\xecd\xa6' ))

def getprinterBitmap():
    return wx.BitmapFromXPMData(getprinterData())

def getprinterImage():
    return wx.ImageFromBitmap(getprinterBitmap())

#----------------------------------------------------------------------
def getreloadData():
    return cPickle.loads(zlib.decompress(
'x\xdam\x8d\xb1\n\x800\x0cDw\xbf"\xe0P\xa7\xd2\x82\xa8\xb3BG\x17\x97\xae"N\
\x8a\xf1\xff\'\xd3P\xa56=\xb2\xbc\xc7\x91k\xce\xdbV\x8b\xb2\x1d\xd0\xb5`U\
\xb5.J\xc3\x06\xe3\xb9n\x07\x13\x10\xcdx\xed\x0c\x9e\xa0v\x83\x9b\xdc\xc0\
\x8c\x81\x8d\xe9\'cbY\x7f\x01\xca+}\x0c[!\xbd\xce$\x86&u\xff\x12\xb9\x9cJ\
\x0c\xc9$\x96\x9a\xc8\'e\xdc\x12\xebBbA\x96\xd6\xdf\xf1\xc2O)}&\xd3\x04\xa9\
\x1f\xf9}h\x94' ))

def getreloadBitmap():
    return wx.BitmapFromXPMData(getreloadData())

def getreloadImage():
    return wx.ImageFromBitmap(getreloadBitmap())

#----------------------------------------------------------------------
def getreportsData():
    return cPickle.loads(zlib.decompress(
'x\xda\x8d\x901\x0b\xc3 \x10\x85\xf7\xfc\x8a\x83\x0e\x16\x04I\x96\xea\xac\
\xe0\xd8\x1b\xb2d\r\xa1SC\xaf\xff\x7f\xea\xe9\xd9R\x8dC\x1e"\xbc\xef\x9e\xfa\
\xf0\xba\xbf\xa7aV\xd3\rx\xf1\xa6\x86uV\x00\x1b\xf8}\xdd\x9e\xd9!\xbb\x8bu6X\
\x97\xbda\x7f\xa7\xd7#\x9b%\r\xa3\x8b!\xcaP\'?\x8e?O\xc9{\xe7\x83w\xe5\xea"#\
\x12\xb8\x88\xbe\xb4\x86\x04\xbd\xa4d+\x98\xf8\xa9$ \x11B\r\x01\xb5&L\xf4\
\x1f\x92\xe6$\xb5\x90:\x90\xaf\xd4\xed\xf1\xf2\x10v*!\xb7:\x96\xe7A\xfdK\xb9\
|\x81\xa6\x11C\xf3\x01\xae\x9dh\xa5' ))

def getreportsBitmap():
    return wx.BitmapFromXPMData(getreportsData())

def getreportsImage():
    return wx.ImageFromBitmap(getreportsBitmap())

#----------------------------------------------------------------------
def getsaveData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"\x13\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\
\xe4l0/\x02\xc8S6\xb70w60\x00\xf3\x15\x80|\xbf\xfc\xbcT0\'\x1f$\xe9d\xe1\xe4\
\xecd\x01\x95D\x05\x10A=\x14\x00\x13\x8c\xd0\xcb\x87\x02\xbd|l\x82XUFPM0\x02\
\xe6\x9e\x08dA\x04\xc0\xa2\x12\x8bv\xacf\x12\x14T\xc0\x16 \x98A\xa7\x07\x00u\
\x06a\xf0' ))

def getsaveBitmap():
    return wx.BitmapFromXPMData(getsaveData())

def getsaveImage():
    return wx.ImageFromBitmap(getsaveBitmap())

#----------------------------------------------------------------------
def getsnapshotData():
    return cPickle.loads(zlib.decompress(
"x\xda\x8d\x8f\xbb\n\x021\x10E\xfb\xfd\x8a\x80E\x84\xc0\x90m$\xb5BJ\xa7\xd8\
\xe6\xb6\xcbb\xe5b\xfc\xff\xca\x99\x89\xd1\xac(x\xc9\xeb\x9cIB\xb2_\xef\xe30\
\xf9\xf1\xe0\xa4\xc9\xe0\x87y\xf2p\x8b;\xae\xf3r5rB\xbb(I\xd1\x98\x95SL\x8dI\
\xf8\\n\x17\x83\xa2\xc5\x9c\xf2)'\xe3P\x0f\xbf\xd8\xbdC\x9a\xdf\x12\xa5\x05\
\xbddf\xeb\xf8s'\xc0\x9b\x9d\x90\x82NL@\x93\xd8\xa4I\xbd\xcf\xa2\x8b*k\xe4bV\
[%\x91\x08p\tj\xa5\xf5R]\xf8\x94\xfcEJ\x0f\x01\x9d\xe4\xfeE\xfc\x94\x96\xfeG\
\xf4\x00K=t\xa7" ))

def getsnapshotBitmap():
    return wx.BitmapFromXPMData(getsnapshotData())

def getsnapshotImage():
    return wx.ImageFromBitmap(getsnapshotBitmap())

#----------------------------------------------------------------------
def getsort_A_ZData():
    return cPickle.loads(zlib.decompress(
'x\xdau\x8d\xbd\x0e\xc20\x0c\x06\xf7>\x85%\x860Y\xc9\x00\xca\xcc\x03\xd0\xa1\
K\xd6\xaa\xeaD\x85y\xff\t\xdbq~ \xea\xa7\x0c\xb9\xd3I\xbe\x1e\x9f0-.\xdc\x81\
\xdf\r\x82\x9b\xd6\xc5%\xd8\xe0q\xac\xdbK\t\x99.\x9e\x17\xbd2\tG\x1f\x0b\xcf\
\x99e\xca\xc0\xfc\xa4\xf7n\xf0\xbb*\xd1D\xea$!\x8d\x12\x11\x07I\x08\x96v\x12\
\xb1\xa4M\x92\x88\x9c6)\x99\xa5\xfd\xa1\xba&g\xdd\xbf\xe4\xdf \xabK\xb2*\xad\
#vT\xa49M\xdb!\x89sJ\xe7\xd7\xf1\x0b\xc8\x1bS\x99' ))

def getsort_A_ZBitmap():
    return wx.BitmapFromXPMData(getsort_A_ZData())

def getsort_A_ZImage():
    return wx.ImageFromBitmap(getsort_A_ZBitmap())

#----------------------------------------------------------------------
def getsort_Z_AData():
    return cPickle.loads(zlib.decompress(
'x\xdam\xcd1\x0e\xc3 \x0c\x05\xd0=\xa7\xb0\xd4\x81N\x08\x86F\xcc=@=da\x8d\
\xa2N\x8d\xe2\xde\x7f\xaam\xe2\x02"_\x0c\xf9O?p\xdf\xbfqZ\\\x9c\x81\xcf\x03\
\xa2\x9b\xd6\xc5e\xd8\xe0\xb9\xaf\xdbG\x1bq\xbb\x05N\n\xdaQz\n\xc9\xba/]\xa2\
\x1d\xb8\xbf\xe8x\x9f\xa5OA\xafQ\xc8\x15\xf9k\xc0j\x1d\x9a\xb5\xf8\xb7\xf6N\
\xbdt\xc0\x8b\xd7\x9btH\x17\x88\x84#\x12\xe94K\x0c\x91@\xa7\xc8\x86\x86Duj\
\xbf\xa3\xc09EC\x99\xd9\xb4<\xe4\x7f\x9d\x85TU' ))

def getsort_Z_ABitmap():
    return wx.BitmapFromXPMData(getsort_Z_AData())

def getsort_Z_AImage():
    return wx.ImageFromBitmap(getsort_Z_ABitmap())

#----------------------------------------------------------------------
def getsqlData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"#\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0\
O\x01\xc8\xf3\xcb\xcfK\x85rP\x01U\x04\xf5\xf4\x80L=(\t\x15\x042\xf4@<\x90\
\x00\xb2\xa0\x02\x16A=LA\xb0q\x18\x82\nX\x04\xf5\xb0\t\xa2:IO\x0f\xc5\xf1`Q\
\xaa\xf8]\x0f\x00*\xac?\xb8' ))

def getsqlBitmap():
    return wx.BitmapFromXPMData(getsqlData())

def getsqlImage():
    return wx.ImageFromBitmap(getsqlBitmap())

#----------------------------------------------------------------------
def getvertical_separatorData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV74S\x00"c\x05Cu\xae\xc4`u=\x85d\x05e\x0b\x03\x10\x04\
\xf3\x15\x80|\xbf\xfc\xbcT0\'\x02$\xe9f\xe1\xe6\xecf\x01\x95\x04\x03\xbd\x08\
(cT\x90\x12A=\x00\x90*Cr' ))

def getvertical_separatorBitmap():
    return wx.BitmapFromXPMData(getvertical_separatorData())

def getvertical_separatorImage():
    return wx.ImageFromBitmap(getvertical_separatorBitmap())

#----------------------------------------------------------------------
def getvertical_separator_thinData():
    return cPickle.loads(zlib.decompress(
'x\xda\xd3\xc8)0\xe4\nV7S04S0V0T\xe7J\x0cVWPHV\xf0\xcb\xcfK\x05s"\x80\x1ce7\
\x0b7g7\x0b0_\x0f\xc47\xb5\x00A\xa8b\xbd\x08\x05\x85\xa1\xc2\xd4\x03\x00\x0c\
\xfe/P' ))

def getvertical_separator_thinBitmap():
    return wx.BitmapFromXPMData(getvertical_separator_thinData())

def getvertical_separator_thinImage():
    return wx.ImageFromBitmap(getvertical_separator_thinBitmap())

