#----------------------------------------------------------------------
# This file was generated by encode_bitmaps.py
#
from wx import ImageFromStream, BitmapFromImage, EmptyIcon
import cStringIO


def getAutoRefreshData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x04\xdaIDAT8\x8d\xc5\x95[lTE\x1c\xc6\xbf\x999g\xcf\xee\x9eno\xb4\xdb\x0b\
\xf6\x02\x04R\xe5"\xd2\x96B\xb9\x95\xd6\xc6\x07\x91D#\xa4\x91\x12cb\x84\xf8\
\xe6%F\xa31\x1a\x13\xa2\xc1H\x82D\x84\x10\x0c\xd2\x0b\xa2\x0f\xa6\x06\xc5D\
\x85\xd2\x06l\xcbB\x0b\xa2\x85\x12\xa5K\xb77h\xb7\xdd\xed\x9e\xdd\xb3\xe7\
\xcc\x8c\x0f\xecB[k\xe2\x9b\x93|\xc9d\xfe\xff\xf9\xcd\xcc\x97/\x19\xe0\xff\
\x1c\xdbNnc\xff\xa5oSsE\xf1\x9a\x93k2\x01\x80\xcc\xd5Ps\xac|\t4\xf5\r\x06T[\
\xdc\xce\x13R\xa8\x94(S\x94\xd1Q!\xf9/\xd2\x16_\x87\rq\xce\xb7\xcbg%\xf7T7U\
\xe4p)\xce\xc7\xa5]}\xa1\xfer\xffL\xb0\x04y\xfcD\xe5\x11\t\xd4\xad+\\\xef(\
\xf1.U<\x9a\x0eF\x18b\x96\t\xc3\x8a\xc0?\xd9\xcf\xbb\x07/GF\x8d\x11F$\xf9H\
\xa8\xe1}.3\x85F\x19\xe9\x82\xe0KT.\x8b~z\xde\xe7\x9f\x01\xae9\xb1\xf6\x8b\
\xa2\xb4\x05\xdbw\xac\xd8\xe96\xb9\x89Pl\x02\xba\xe6\x81[\xd5AAA\t\x81\x04@\
\tA\xd8\x0c\xa3\xed\xd6\xd9XG\xa0#\xce\x89\x18\\_\xb0~\xe1\xef#\xbfYAc\xa2\
\xa4ug\xe7\x80\x92\x84V}YZ\xa1\xab)\xcf\xd6,\xacu\x1f\xec: \xeeD\xefR\x05\
\x146\x17\x92Ri{\xddy\xd1\xb2\x82r}Un)\xb3 `\xca(6/\xaaq\x96>T\xe6\xbc9v\xd3\
S]\\K\xae\x0ew\xdb\x16\xb3\x04\x00\xd0$\x98)\xce\xdd\xa9j\xaa~\xd4wD\x86\xac\
0\xd1UW\xcc\xe6\xfcdk}\x07\xb5d4g02P\xfb}\xdf\xa9o\xf6\x9c\xfb\xc0\xf0\rvJ\
\x17\xd31\x18\r`\xc2\x1eG\xf9\xfc\xd5D\xa1\nL\xce\xa1\x9a\xcaL0!\xf2\x89\xfe\
\xb0\x9fdz2\x83Kr\x17_\x8e\xd9f\x10\\\xee\x05\x80\xf6\x1dW\x83m;|\x9dg\xea.\
\xd4E\xb9\xb5\xee\xc7\xbe\xd3]G/\x1e6\xd2h:\xe6\xbb\x0b\xd1>z\x16*u\x00R\x90\
83g\x829\xa0\xb9\x1c\xae@\x91\xb7\xe8\x90\xee\xf44\x80\x92\x1b\xd4!\x82\xb3\
\x13s\xbe\xbe\xab\xdb\xb6\xad\xb7B\xf1\x10s\xab\x1e\x0cG\x03\x00\x044\xea\
\x84\r\x9b8\x98*\x00\xe0\xbe\xc7\x10\xdcHse\xed\xd7]\x9e\xef\xc2\x0e\xf3\xae\
\x01qL\xcbM\t\xcd\x06ol(]N\x89\xd2\xf2R\xd9\xcbZ\x8e\xdb\x8b|=\x0f\x95\xde*h\
L\x03\xe7\x9c\x98\xea,\xb0\xc8w.x\xe4l\x8bx\x7fK\x8b\x98+\xdb\x00\xb0\xe1xi\
\x9e \xe44\x11\xdc\xfdY\xe7~SJ\tN$\xa8\x94\x10\x12\xe0\x10\x0e-r\xcf\x8a\xfb\
q\xabj(\xbf\xc3)R\xe6$\n\x84\x15Aj\xb5\xac\xf1\xde\xe8\x88\xee\xfa\xb7\x83c\
\xb6S\xebx\xb1c\x14\x04\xf2\x81\x15\x90\xe9\xc7\x9elVT\xea\x80$\x12\x14\x14\
\xa6\x1d\xc3{\xe7\xde6\xfdS\x7f\xbdz\xa6\xbe\xab\'\xd1h\x02@\xe9\xa1R5#\x03\
\xee\x87WV\xc62\xe3\x99\x19}\xb7{*\x03\xe3\x03\x87A\x905\xc3\n\x1b \x9a\xe2D\
\xfb\xc8\xcf \x92\xa0<{\x1dN\xfc\xd1h\x0eD\xfa\x0f\xb4>w\xb1a\xf6\xedR\xdc,\
\x07B9\x98:\xe5\xf86&\xc2\xd9\x93\x91\xc9]\x8ci<Y\x7f\x90\xe3\x84/qa#_/\x80\
\x04pu\xb4[RI\x97\x975\x97\x15\xcc\x063 \x95K\xbe6d\x84\xeao\x04\xae\xbd>\
\x15\x0b\x17+\x92\xfc\x99\xacO\xb3\x02\x84\x80bY\xfa\n\x0c\x19\x03P\xa8\x82\
\x0f\xab?q~\xd5\xdbX\xf3C\xdf\xa9\xde\xcdM\xab?\xb58\xbfH(\xfc\n\'\x8a \xe2c\
\xa7\xeaJ\xef\r\xf4V9\x99Cf\xe8\xf3\xac\xb1H\xf0\xc8\\`\x10B`\xc4\r,N[\n\x8b\
\x9b\xb8\x12\xf4ac\xe1&V\x9e_\xe1\xf6\ru\xbd6\x1c\x1a\x8a\x05\xc2\x012\x16\
\x1b\xd3U\xc2\xe0u\xe5\xa0\xc4[\x82,=\x9b4u\x1f\x8fQ\xcb\xd5\xf8\x0f0%\x94\
\xf4\x87n\xe1\x9d\xd67\'\x08\x18\xdd\xb2\xe8)\xc7\xa6\xa2\xcd\xce\t{\x1c\x12\
\x02+\xf3\x1eS\xac\xdce)\x0c\x14\x04\x14\xb6\xb4`\t\x1b\x93f\x10\xcd\x97\x1a\
\xa6,[\xbe\xd2\xf6Bkl\xba\xb5\x00\xc0\x8a\x9f\xc9\x7f\xb7c\xe0B\xa4\xbf\xd5\
\xbf\xb5g\xff\xf5}\x81T\xff\xe0\xaf\xc1\xb6E\x13\xb1I]\xa5*\xf5h\xa9\xc4\xa3\
z  `\x0b\x1bS\xf10|\xb7\xbb\xc4\xa9\xeb-\xe6\xe4\xf0\xd4\xde\xf3\xbb/5&x\x12\
\x00O\xe6\xd8\xb9\xa1qUp\xf2Zd\xfb\x95=\xd7\xaf\x01p%\xe4,\xdc\x9a\xff\xe8\
\xfc\x1ao\x9d\x92\xe1X\xc5\x88\xd4tG\x8a\x15\xb5\r&\xa4\x84\x15\x16\xed#m\
\xa3\x07o6\xf9{\x00D\x132\x00\x18I0\xa9\xf8|\xc5\xd3\x1d\xbb\xaf\xb4\x02p\
\x02\xd0\xa6IM\x88\xb1yL\xcd^\x96\x99\x19\x1e2\x82\x91\x1b\x91 \x808\xee\xe5\
\xdaL@\xc3\x89\xb9\x9c\xebkb\xd3`I)\xd3\x9f\x99\x90\x95P\x1c\x80\x9dX\xbb?\
\xfe\x06\x90\xc48\x06"\xd8\x87_\x00\x00\x00\x00IEND\xaeB`\x82' 

def getAutoRefreshBitmap():
    return BitmapFromImage(getAutoRefreshImage())

def getAutoRefreshImage():
    stream = cStringIO.StringIO(getAutoRefreshData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getCopyData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x02vIDAT8\x8d\x95\x95\xcfO\xd4@\x14\xc7\xbfo\xa6ewI`o\\9\x10l\xd7\xbfB\x0f&\
\x1a\xaf\xfe\x03\xdeE\t\x065z\xe2`\x82 B0\xfe\x88\x1a\xfd3\xbc\x98\xf8#\xc8F\
E\x94\x04\xd8%{\xc6\x03\x90\x18\x08\x84\xedN\xfb\x9e\x87n\xdb\xedR\xca:\x97i\
\xe7M?\xf3\xe9\x9b\xe9+\xcd-\xcc^\x17\x0e*\xf8\xcfFJ\xd7n\x8fO\xbe;-n\xb5<\
\xcf\xbdw\xe7\xc1\xffr\xb1\xb0\xf8\xc4\xcd\x8b[J)\x00\xc0\xfe\xfe\xdf\x9e\
\xa1\x03\x03e\xa83\xe6XyAf\x901\x9e\xee\x1aC_\x9f\x07\x11H\xcf\xe0\xad\xadF\
\xe7-\xfd\xfc\xfd\xe3\xda\xd1\xe1\xe10\x11u@\x08D\x80\x88`vn\xfaV7\x90\x88\
\x88\x08\x9fR`\xc7\x19\x8d\xaf=\xcf\xd3\x1f?\x7f\x18\xbe;y\x9fD\x84\xf2\xec\
\xba\xc0\x98\x9b\x9f\xb9p\xaa\xb1\xef\xfbh\x9b\xd2\xc1\xc1~\xaf\\\x0c\x0e\
\x96!"r\xaa\xf1\xf1\xb1\x87\xaf\xd5/=\x03\x810=Q\xcb1n\xa5&\xd6j\xb53\xa1\
\xae\x9b|\x0e)\xf0\xe8hd\xccm\xe3\xa58\xe6\xba\xd9\xc76Z\\D\xb2\x8d\x99\x81F\
c\x0b\xcc\xd9\xc6\xf5z=\x13\x9aL\x11T*\xe7\xb3\x8c\x19##\x89q\xd3k\xa1\xfam9\
\x8eV*\xc9k\xa6-C(\x11\xe5\x197\x000\x98\x01c\xcc\t\xe3N`\xd8G\x8b\xba\x10\
\x01\n\x85B\x1a\xcc\xccm\xe3\x918\xd0l6\xf1}\xa5\x1a\xdf;\x8e\x13\xdbu\x1b\
\x13)X\x96\x861\xa6\xcdj\x83}\xdf\x8fs\x1b\x19\x03\xf1\x00D\x04\x9b\x9b\xd1\
\xa9\x90\x8e\x05\x80\xfe\xfe~\x94\xcbe\x00\xc0\xd0\xd0\x10\x82 \x80\x88t\x1a\
\'}\xd8T\n\xec8\xe7R@@\xa0\x94\x86\xd6\x1a\xcc\x8c\xa8\x98\xc5\xc6\xcc\x0cc\
\x0cJ\xa5\x12\x82 \x88a\xb6m\xa7\xc0a\x8dHN\x81m\xdb R\xa1\x9de\xc5\x9b\xb7\
\\]\x023\xc3\xea+\x14\xea\xcf_>\xcd(\xf4\x02"\x05fN\xed\xbe\x08\xa0\x94\x8ac\
\xaf\xde\xbc\xc8xTjV\xde_`z\xe6\xe1\xcd(g\xdd\xaf/"a\x1a \xb8r\xe9*\x00`wo\
\x07\xab\xbfV\xc0\n\xafs\xeb1\x80\xf6f\x84\xe9\xb0m\x0bZ\x87\x8f\x84\xd6\x04\
\xad\xc3r\xbd\xfdg\x1b\xeb\x1bk(\x96Jo\xc7\xc7&\x16\xcf\x04\x1bcP,\x16S\x9f\
\xac\xd6\x89u\x100v\xf7v\xb0\xbe\xb1\x06Q\xb81>6\xf1\x0c\x00r\xeb\xec\xe3\
\xf9G\xef\x03?\xb8\x1c\xa6\xed\xe4\x0fC \x10\x80\t\xb4\xda<j]\x9c\x9a\x9a:\
\x8cb\xff\x00\xceF\x80\xd8+\xe7)\x16\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCopyBitmap():
    return BitmapFromImage(getCopyImage())

def getCopyImage():
    stream = cStringIO.StringIO(getCopyData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getCutData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x04>IDAT8\x8d\x85\x93klTE\x14\xc7\xffs\xef\xdc\xbdw\xbb\xa5\xc5\xed\xc3\xb6\
\xdb\x966Q\\\xa3\xa55\x04[\xa0%T\x1a\x0c\xc6\x0fD\xd3\xf8\x88\xa6_\x9a\x94(`\
c\x02E\x05\rBb\xa1F\x9a(\t\xc1\xc7\x07L\xb4/-\x94\x184U\xa4\x88\xe1\xf1\x010\
\xad\x10\x8a\x92Z\xda\xael\xdd\xd6\xdd\xde\xdd\xbd\x8f\x99;~\xe8nR\xd7v=\xc9\
d\x92\xf9\xcf\xfc\xce\xff\x9c\xcc!H\x89#\x9d\x1d\x17\x1d!jl\xd3\xac\xdb\xb3g\
\xdf\x85T=\x19\xed\x87\x0f\xb6\x02\xe4\x88\xa6\xb9\'[w\xbe^\x9c\xaaK\xa9\x97\
\x89$U\xafYS\x8d\x9c\xdc\xbc\xc1\xa5\xa0\x00\xa0i\xee\x8e\xa7\xb6<\rI\x92|\
\xef\x1d>\xd8\x9f\x16\xec\xc9\xf0\xbc\xf2\xe4\xe6-\xa4\xac\xb4\x1cT\xa6\xda\
\xf1O\x8e\xed_\x0c\xfa\xe1G\x9d]\xbe"\x1f\xbdo\xb9\x17\x1b\xea6\xa2\xe0\xfe\
\x82\x8a\xb4`\x9bq_nN\x1e\x00\xa0n\xc3F@\x88\xb7R\x1ftt\x1cXaZ\xe6s5\xd5\xeb\
\xc09\x87\xa6i\x88Fc%i\xc1\xa6i\x8e\x0e\x9c\xeew\\.\x17\x14\xaa\xa0\xa0\xa0H\
\xfe\xfc\x8b\x13g\x17\xde\xc9\xc8\xcc>\xb9\xb6f\x1d\x18\xe3\x90$\t\xe7\x86~\
\x80\xaeG\xda\xd2\x82\xa9\xe4l\rN\x07\x89a\xc4!\x84\xc0\xaa\x8aJD\xf5\xb9\
\xfa\xa4\xde\xde~\xa0\x96s^U\xec+\x85\x10\x02\xf7\x82\xf7`\x9a\xe6\xdf{v\xef\
\xedL\x0b\xde\xb5k\xdf\x1f\x00>\xeb?\xf5\x95\xf0x<\x10B\xe0\xb1\xca\xd5\xe8\
\xe9\xed\xba\x05\x00\x99Y\xcb\xbey\xa2\xbe\x01\x8c1PJ1t\xfe,,#Z\x95\n\xfd\
\x0f\x18\x00\xdeh\xdb\xdbl\x18f\xf8\xc6\xcd\x11A\x08Ann\x1e\xe6\xe6"+?\xfe\
\xf4x\xe7\xf2lo\x96\xa6\xba!\x84\xc0\xb5\xebW\xa1\xba\xd4\xee\x84\x99\xff\
\x07\x03\x80\x80\xb3\xed\xf2\x95K$#c\x1e\xb2\xb6\xa6\x16YY\xcb^+)]\x01!\x04$\
\x89\xe0\xee\xc4\xb8\xb5c{\xeb\xf3\x8b\xbd_\x12\xfcf\xdb\xben\xee\xf0\xa1\
\x9f.\x9cwdY\x86\xa2(PU\r\x9c1\x10B\xf0\xdd\xe0\xb7\xd0#\xe1MKA\x97\x04\x03\
\x00%\xa2\xe9\xb7\xdfo\x0b\x10\x01!\x04\xfc+\x1fF4\xaa\xe3\xce\xd8\x1d\xc8\
\x92|#\xddT\x02\x80\xbc\x9408\xf8c\xb8\xa1\xa1\xde\xfd\xe7\xed\xd1Z\xff\xaa*\
\xd8\xb6\r\xcb\xb2\x10\xbay\x03M\xdb^\xcdO\x07M\xeb\x18\x00\x1e\xda\xbb\xdf2\
\xc7\xc60\xf2\xcb5\xf8\xfd~\x12\x9f\x9b\xc3\xf4\xe8-\xf4+\xca\xa2\x13\xb90H\
\xea\xc1\x97@\x99GU\xf7\xcb\x92\xd4h0\xa6U<\xfa\x08\t\xb9\xdd\xb8{\xf9\nJ\
\xaa\x1fGN<\x8e\xe1\x91_\x85F\xa9\xc1\x1d\xa77j\x9a\xef\xbc\x00\x8c\xa5\x05\
\x9f\xa4t\x1b\xa5\xf4\xed2\xaf\xb7PS\x14(\xd2|A\x97\xc6\xc7\x05\x01\x88\x00D\
Mi)\x01\x00\xdbq`\xd86\xc6ff\x02\x8c\xb1w\xb72vl\xd1V\xf4\x15\x1550\xa0\xcd\
\x9f\x9f_8\x1b\x8f\x87\x86\x03\x81\xd9P,\x86\xa0\xae\xc3\xe6\xfc\x90\xdc\xf8\
\xccq\x9b\xf3CA]G(\x16\xc3p 0;\x1b\x8f\x87\xfc\xf9\xf9\x85\x0ch\xeb+*jX\x14,\
\x19\xb1\xe6\xf5\xe5\xe5e\xa1h\x14A]\xef\xb18?\xeaV\x14LE"\xe0\xc0\xf5g\xbbz\
[\x04pm*\x12\x81[Q`q~4\xa8\xeb=\xa1h\x14\xeb\xcb\xcb\xcb$#\xd6\xbc(XX\xec\
\x01\x8dR\xe8\x96\xc5\xa6\x1dg@\x95\xe5\x16\x8f\xcb\x05\x02L6\x01\xa7\x01h/\
\x03\xa7\x080\xe9q\xb9\xa0\xcar\xcb\xb4\xe3\x0c\xe8\x96\xc54J\xe1X\xf6\x83\
\x0b[K\x93\t\x88m\x17G\x0c\x03\xd9\x9a\x86JJ\xcf\x14{\xbd\xb8:99=\xceX\x0f\
\x00\x1f\x00\x01\x00\xe3\x8cu\x93\xa9\xa9\x97V\x97\x94\xe4O\xcc\xcc\x9cQ(e\
\x11\xc3\x80d3\x1f\x00\r\x80\r\x80K\x89,\x92J\xe9\x89\x89p\x18\x99\x8aB\xdd\
\xaa\x8a\xe1@\x00\xb3B\xfc\xbc\x83\xf3^\x00\xde\xc4\xca\xdb\xcey\xdf_\xc0\
\xc5\xe1@\x00nUE\xa6\xa2\xd0\x89p\x18BQ\xba\x00\xa8\x98\x9f\r\x92\xb4.\x03\
\xa0\xbd\x9a\xb6[r\x9cM\x0e@\x02\x8e\xf3\xfdN\xc6\xbeNhNJ\x85\xec\x03Yn\xf4\
\xc9\xf2&\np\x93\x90s/\x9a\xe6\xfb\x00X\xd2\xf1\xc2\xefF\x92\xee\x13\x8b\x02\
P\xf0\xef/\x99\xac\xd0I@\xf8\x82\x1d\x89v9\x00\xf0\x0f{\x1d\xd6\xad\xc1\xe5\
\x93\x8f\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCutBitmap():
    return BitmapFromImage(getCutImage())

def getCutImage():
    stream = cStringIO.StringIO(getCutData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getLocateData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03\xc9IDAT8\x8d\x85\x94\xc1oTU\x14\x87\xbf{\xdf{3\xa5\x8f\xc0\xb4a\x90&\
\x9a7W\r\xc4\x06\xed\x98\x90`\x86E!\x18\xd8\xb95"\xa6\xfe\t\x85\x85+T\x12\
\xf7\xda\xad\x0b#5i\xc3\xc6Hpa\xa8\x9b\x9aP\x8c+\xc6@P\x0c\xe9\xcc\x0b\xb5\
\x96\x19fl\xd1\xf7\x06f\xfa\xceu\xd1\x99\xe9\xccP\xf0$wqs\xce\xfd\xee9\xbfs\
\xeeU<\xc7L\xc1,f\x0fe\'w\xf2\xc5\xb5\x98\xdbWo\xabg\x9d\xdd\xd1a\nf\x06\xc8\
\x03\x13\xec#Cj\x87\xa0\x1a\xd0\xa4\x88e\xa3t\xa3t\xfc\x7f\xc1m\xe8T\xf6H6\
\x83\x0b\xd5\xb5*\x94YD\x91\x03rXf\x19e\x8aa\xc8\xbe\x98%.\xc7D\x0f\xa2bi\
\xa9\xf4\xe63\xc1\xbd\xd0\xea\xc3*R\x92\xf7\x1c\xc7\xb9\xafE\xaf%$_\xa1\x98$\
\xe1\xa8r\x95\'"\xbe\x1aU\xd7\xfc1\x1fj<\x05w\x9f\x07\r\x7f\x0e/\xf7\xf8\xbb\
\t,__^\x02\xc8\x15r\xa7#\xa2k\xfe\x98\x8f\x8f\x9f7\xc7\xcc\xcd\x0e\xbc\x0b\
\x06\xf2\xd9\xb7\xb2\x99\xeaZ?\xd4\x9c53X\xf2\xb4\x98@\x00\x97/\xcd+fC\xacL\
\x97\xe7\xcb\x0b\x83\xf0\x0eL\xf7d;Q\xad<\r\x15\xa4(\xc8E\xea\x94Y\x07\x89dV\
\x90\x8bZ\xeb\xe9\xe0L\x90/\xdf(/\xd8\xba=\x1d\xfd\x15\x11=\x8a0\xc7\xcc\xcd\
.\xb8\x93-\x02\x83P\x1c\xae\x84s\xe1"1\x1b4\x80:\xc5p.\\\x14\x91\x99^8\x00\
\xa3\x90=\x98\xcd\xf7\x82\x01\xb0\xa1\x9d\xda\xde\x90\xc7R\x0eg\xc3u\x00A\
\xa6\x059\x81K\x11 \x9c\x0f\x8bXr(2\x00\xb6nO\x13o\xb3z5\x06\xcb\x07\xa6`N\
\x02\x01-&t]\x7fa\nfC\x90\xe9\xf0FX\x1cht\xbe7\x86\x01\xeb\x03+\xa5\xde\xeen\
dK\xa2\xf6@f\x06\xce\xe5QL\x0e\xc4\xf4Y\xbf\x14\xd8\xa9\xd2RI\x95\x96J\n\x97\
\xa2\xec\x92s\xbd\xe5o\xdf\xb9-K\'F\x90\x13\xcf\xcexD\xcd\x02\xdf\x00\xe0\
\xb0\xc1\x1e\x8a\xe1\xf7\xe1bo\xf9\xbd\xb2\x98\xf7M7\xc6\x9c4\x96\xa1\x1d2\
\x8e\xcb1\x0cC\xae\x90;\x05P\x9a+\x1d\xd7J\x7f\x18\x9c\t:\xb3\xb9U~\xbbY\xe6\
\xac\x99\x11%\x97\xba\xd5\xec\x02\xe2\xad\xcf\t\xdaO:(\x04y\xad\xf4\xd7\x8c\
\x91\xe7\xf1V\x87;#d\xce\x9aKXr\xed\x07\x92\xc1\xa5\x88\xc3\x86(\xb9\x84\xc3\
\x95p6\\7\'\x8de\x04X\x07i\xc8\xb9p)\x9c\xe9\xca\xde\xf9"\xabQ\x15b\xe0!\xef\
$\xab\xc9u\xa5\x94\x05\x86\xd4\xab\xeaG\xa5\xd4a\xeb\xd9O4\xfa\x87M\xd9\xfcs\
\xf7\xfd\xdd\xb5\xc6X\xe3\t#\xe0\xbb>\xc4t\xbf\xd2\xae\x14\x89$\xe7+w+\xb7\
\xb2~\x16\x86\x81}\\\xd5\xfb\xf5\xa9t:\xedz\x9e\xe7\xaaX\xfdC\x03\xa8\xf1K\
\xf3Vs\x99\xdfx<\x08\x8d\x1eF\xe7\x83\xc9 \xd3\x07v+\xee\x8am\xd8\x8f*w+\xb7\
;pu@]n\x1dlU[\xa3\xad#VY\x0b\xa0D\xa5\xbdC^\xcdy\xc3\xa9\xf7A\x1fD\x17$\x92\
\xef\xc2\x9f\xb6\x1e\xd4\xb6\x14\xc6\xbc\xa0\x94J\xdbQ{\xd0\xa6\xec\xe7\xfb\
\x0f\xed\x7f\x1d\xa0+M\xaf\rm\x01\x87w\r\x13\xd7b\xa2\x07\xd1\x85\xa4\x91\
\xcc\xa7\xe2\xd4\xbf\xf7\xee\xdd\xab\xf6\x81\x83 8\xe0y\x9ek\xadU\xc9H\xf22\
\x9a\x0c.\x9fu.\x18\xb4\x0e\x90\x84\xdfu\xac\x7f\xb5\x8f\xed\xa3f\xb3\xb9\
\xb9\xb2\xb2R\xef\x03\x8f\x8f\x8f\xa7\xa2(\x1aVJ\xedu\x1c\xc7\xb3\xd66\xd9\
\xc3a\x1c\xf6\x8a\x12Q)\xf5)\x8a\xd7\xec\xa6\xfdXo\xeae\xd1\xb2i#\xfb\x07\
\x11k\x8e\xe3\xa4\x92$y\xe4\xfb~|\xe7\xce\x9df\x1f\xb8m\n\xd0A\x10x\x8e\xe3\
\xa4\xb5\xd6)\x11Q\xcdf\xd3\xf3^\xf2\xbeEs\xd46\xed\xbb\xb6b\x17\x80!\x11\
\xd1I\x92<Y]]\xfd\x1b\xb0\xed\x05\xc0\x7f5\xbc\x06pV\x18Y|\x00\x00\x00\x00IE\
ND\xaeB`\x82' 

def getLocateBitmap():
    return BitmapFromImage(getLocateImage())

def getLocateImage():
    stream = cStringIO.StringIO(getLocateData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getLocateArmedData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x18\x00\x00\x00\x18\x08\x06\
\x00\x00\x00\xe0w=\xf8\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x01~IDATH\x89\xb5U\xc1\x8d\xc2@\x0c\x9c\xe5\xeeO\x07\x14@\x03@!H\x14\xc0?\n\
\xd4\x91D\xfb\xa7\x00$\n\x01\x1a\xa0\x00:\xa0\x82\xbd\x07\x1a2\xf1z\x838\xdd\
\xcd3vf\xec\xb1\x9d\x840\xf9\xc2\x7f\xe2\xfb]\xc2f>Kc\xf1\xe3\xed\x1e\xc6\
\xe2\xa1\xd4\x81\x12WS\xff\xe5\xf8x/4\x19#\xaf\xa6=\xf9e]!>\x9e\xa4\x97u\x05\
\x1b/u\x9a\t(9\x89I\xa8X\x9d\xefA\x85J"\x03\x01\x8f\x1c\x00\xea\xdd>\xd4\xbb\
}fA\xbd\xdb\x87\xd5\xf9iMId0\x83\xcd|\x96<\xf2\xf3\xcao\x9f\xe4\x00\xc0\x9c\
\xf8\x00\x16\xdb\n,\xe8\xd5\x81*[r\xda\xa13\xb8\xac+\xa8\xb0\x8a]\x0f\xd1\
\xb7H\xb7E\xc9\xbb\xb6I\xd6"\xdac\xbb#G\xd76)\x13\xd0\xea\t%?\xde\xeea\xb1\
\xcd\x07N2\xed\x82\xc8\x0e\x8d\xed\xd1\xb2\xeb!b3\x9f%\xee9\xc5\xd4R\xe6d\
\xca^\x07%\xb0\xcaO\x91u0\xb0\xe0\x14\xe1Y\x02<\xed\xea\xda&e9\xa78\xc8\xcb\
\x04\x96\xa7\xf8\xf2\x92\x03\xb4\xb6\xa8]\x9a\xe3\xad\xf3\xc0"~[thKS\x91\xc6\
\xb9e\x1e\x07Q<4\xef\x88,t\x85\xed\xa1\xb1\xabL\x00\xe8wYE\xba\xb6I\xdc0\xf5\
\xdc\x923\x9e]2\xd0{\xcbD\xad\xdc;\xb4\x12\xb9"[SO\xc4\xb3H\x9f[r-\xe6\xcf~8\
\x1e\xf9\xa8\x000\xf4\xbd\x04;\x0f\x1b\x1f\x15P!\xa0\xff\x8cX\x9f=\xe2\x8f\
\x04\x08\xda\xa6[\xf2\x0e\x1f\t\xfc\x06?%\xb3\x0b\x14\x95x1\xa9\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getLocateArmedBitmap():
    return BitmapFromImage(getLocateArmedImage())

def getLocateArmedImage():
    stream = cStringIO.StringIO(getLocateArmedData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getMoveDownData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x047IDAT8\x8d\x8d\x94_\x88\x1bE\x1c\xc7\xbf3\x99\xec\xedmsI\xecyW\xef\xc8u\
\xcbY\xa8\x82\xdc\x05\xee\xa5\x0f\xda\xf4Z\x88!-RD\xaa`\xfb >(>\xd4\n>((E\
\x04\xff<UE\x84\x82\x7f\x90\xbe\xd4>\xf8\xa0\xd4\xe6jK/o\x9e\\A\xa5\xb4\x15\
\xeeb2\x9b^\x92\x86\x92\x7f\x9b\xdd\xcdmv\xc6\x87n$\\r\xc5\x1f\x0c;\xfb\xe3;\
\x9f\xf9\xce\xef\xb7\xb3$\x95J\xe53\x99\xcc\x1el\x89\xfd\xfb\xf7\x7f;;;{4\
\x1a\x8d\x06\xca\xe5\xb2\xc59\xffyuu\xf5\x8d\xad\xba\xed\x82\rK\xce\xcf\xcf\
\x7f\x96N\xa7\x9fO&\x93\x11)%J\xa5\xd2\xce\xabW\xaf\xbeH)mT*\x95\xcf\x0b\x85\
B\xf9\xff\x80w\xa4R\xa9\x13\xbdD\xa7\xd3yLJ\xf9\xcc\xd8\xd8X\xa8X,\xc2q\x1c0\
\xc60==\x1d\x0e\x87\xc3\xfbj\xb5Z\xe0\x8a\xae?\xa9\x00j\x80\x10\xd1u\xdd\xfb\
\x8bw\xef\x16\x07\xc0\x84\x90 \x80\xf3\xbd\x84\xaa\xaa\x00\x00\xce\xb9\xe78\
\x0e\x14EA\xbb\xdd\x06\xe7\x1c\xae\xeb\x82R\x1a\x92\x9e\xb7\xa8\x10\xb2\x8fR\
\xfa*\x0b\x04\xd6~\xd3\xf5\xb7\xba@\xed\xe9B\xe1\x8f\xff\xc0R\xcaz&\x93\x89\
\xf6\xef\x16\x8f\xc7\xbf\x0c\x06\x83\'[\xadVXUU\xb4Z-\x94J\xa5V\xb3\xd9\\\
\xb7,\xab\xf5l\xb1\xf8\x95/}sy\xf7\xeeS!)\xbfW\ti-\xeb\xfa\x0b\x07\x0b\x85\
\xdbCk\xbc\xb0\xb0\x10\xac\xd7\xeb\xdfq\xce\'\xea\xf5\xfa\xa1\xd1\xd1\xd1\
\x80m\xdbv\xa3\xd1\xb8f\xdb\xf6E\xc306\xfa\xf5\x96\xa2\x9c\x83\xeb\x9a!\xe0\
\x9b\xa8\x94\x1fgc\xb1\x8f\xda\xaazg\x00|\xe3\xc6\r7\x91H\xfc\x99\xcf\xe7\
\xcf8\x8e\xf3\x03c\x8c\t!\x1c\xcf\xf3\xfef\x8c\xfd\xb3U\x9f^[\xeb\xfc45u\xc1\
cL\x8f\x12\xf2\x0e(\xbd\x99^[\xfb\x9d\x0e\xebh6\x9b\x15\x8a\xa2l2\xc6:\xc1`\
\xd0!\x848B\x08wbbB\x0c\xd3?W*Y\xd40>\xbc/\xe5\x8fa\xe0\xc4\xb5\x99\x99O\x07\
\x1c\'\x12\tV\xa9T\x9e\x98\x9e\x9e~w\xef\xde\xbd\xc9H$\xc2666\xac|>\xbfT\xad\
V\xbfH$\x127\xb3\xd9lw\xeb\xbaE\xa0{\x05\xe8\x82\x10\x9d\x08\x11\x1f\x00g\
\xb3\xd9n<\x1e\x7f\xfd\xf0\xe1\xc3G\x17\x17\x17\xc3B\x08T\xab\xd5\xe8\xf2\
\xf2\xf2\xb1\x95\x95\x95\xfb\xb9\\\xee,\x80\x8d\xad\xeb\xfa\x83\x10\x92d\x00\
\xc2\xa9T\xeat/\xe9\xba\xee\x84\x10\xe2\x80\xaa\xaa;\x0c\xc3\xc0\xe6\xe6&(\
\xa5\x18\x1f\x1f\x1f\x0b\x85B\x8f\x8f\x8e\x8e\x86\x01\x94\x00\xc8\x87\xc1\
\x99\xbf\xc3\xd9^BQ\x14\x00@\xa1P\xf0\x1c\xc7\xc1\xc8\xc8\x08L\xd3\x04\xe7\
\x1c\x9dN\xe7a,\x10\x7fH\x1f\xdc\xbc|\xf9\xf2\xce~\xc1\xdc\xdc\xdcYJ\xe9+\
\xadV+222\x82v\xbb\x8dr\xb9\xdch6\x9bw\x1c\xc7il\xe76\xe0?{\xe0\x81S\xb4\xdb\
\xed\xaf9\xe7\xe3\x8dF#\xa9i\x1a3M\xd32M3\xe38\xce\x05\xceyu;\xc7\xd4wL\xb7\
\x01w\xd7\xd7\xd7o\xcf\xce\xce\xbeg\xdb\xf6y\xc6\x18q]wSJ\x99\xcb\xe5r\x1b\
\x00\x06\xbe\x08\x00X]X\x08\xb6\xef\xddc\xf2\x81c{\xe8\xdf\r\x80\xcc\xe5r\
\x1c\x00\xdf\xce\xddE p\x1c\xf0\x00\xe0\xba\xaeG\x1b\x95\xca\'\x8f\x04\x02/5\
\xa4\xc4!\xc3\xd0\x86]\x10\x15@\x04\x004M\x93\x00\xd2\xfe\x90\x00t\x00\n\x00\
\x1c\x07\xbc\xa5X\xec\xd6\xf5\xa9\xa9G!\xc4\x07\x91@\xe05\n\x08\t\xac`\x9bR8\
\xfe\x90\x96e\x1d\x01\xf0\x8b\x9f?\xa2iZ\xde\xb2\xac\x19\x00\xc5+33M*\xa5\
\x19V\x94\xf7%p\x8a\x01h\n\x91=h\x18\x87\x00\x80u\xbb\xdd\xa8\xef\x08>\xa47?\
\xd1\x07\xc5\xe4\xe4\xa4k\xdb\xf6\xe9s\xbbv\x1d\xdb\x13\x0c\xbe\x1d"$\xa4P:\
\x16$\xe4T[\x08X\xc0\xaf\x07\x0c#\xd9\xd3SJ\xa9\xabi\xda%M\xd3.\xf9\xc7\xef\
\xcd\xd5\xfec\xd4j\xb5\x92i\x9a\x93\xf7<\xafJ\x00\xe9\x01dSJ4\x84\xf8\xab\
\xe9y\'\x0fp\x9e\xec\xd7#\x95J\xe5\x875\xc7\xafi\xba\xef\xfde\xbf\xe6\xbb\
\x00`)\x16\xab/\xc5b\xf9\xa5X\xec\xa9\xa1\xab\x87\x80\xfb\x1b\xba\xb5y8\xa3\
\xeb\xeaE\xff.,\xc5b\xb7\xe4\x83Ow \xfe\x05[\xc7\xeb\xb9F\xfd{\x8f\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getMoveDownBitmap():
    return BitmapFromImage(getMoveDownImage())

def getMoveDownImage():
    stream = cStringIO.StringIO(getMoveDownData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getMoveLeftData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03\xadIDAT8\x8d\x9d\x94Ml\x1bE\x14\xc7\xff\xb3\x1f\xf1\xdaM\x96M-lH\xd6\t1\
\xaa\xc2\xa1\x92\x83| \xea%\xa8\x82h\xe5"\x14\xdaC/ \xc1\x85\x8a\x8f\x03\x07\
8p\xe7\xe3\x00\x12Ep\x01!\x10\x02\x81D$.\xd0\xc8n\xc2\xc1WH$\xb7R\xac\xc4\
\x11x\xb3I\xb3I\xbaJ\xd6^\xef\xae]{w8\xc4N\xd7\xadq"\x9e4\x9a\x99\xff\xce\
\xfe\xf4\xde\x9b\xf7\x86(\x8a\xa2f\xb3\xd9\'p\xdfX\x00\xde\xf4\xf4\xf4\xb7\
\xc9d\xf2\x05I\x92\xd8\xdd\xdd]G\xd3\xb4\xdf\\\xd7\xfdbuu\xb5\x04\xc0\xc3\t\
\xc6\xf5\xd0\xbcT*u=\x93\xc9\\\x9e\x9d\x9d}\x84R\n]\xd7\xcf.--]]^^\xae\x8c\
\x8f\x8f\x7f\xbe\xb9\xb9\xb9{\x1a\xf0\x19EQ^\xee\x08\x8dF\xe31\x00\x17EQ\x1c\
\xda\xde\xdeF\xbd^\x07\xc7q\x18\x19\x19\x11EQ\x9c4MS\x02\xb0\x07\x80\xf6\x05\
\x13Bx\x00?t\x04A\x10\x00\x00\xe5r\xd9w]\x17\x03\x03\x03\xb0m\x1b\x9a\xa6\
\xa1\xd9l\x9e\xe4\xe8}0\xa5\xd4\xccf\xb3RP\x9c\x9a\x9a\xfa\x92\xe7\xf9Wl\xdb\
\x16\x05A\x80eY\xd0u\xdd\xaaV\xab\x7f\xbb\xae[=\xc9\xdbN*\xba,\x9dN\xf3\xa6i\
~\xa7i\xda\xa3\xa6i^\x0c\x87\xc3\xac\xeb\xban\xa5R\xf9\xc3u\xdd_\x86\x86\x86\
\x8c\xd3x\xcc<(\xac\xac\xac4eY\xbeU(\x14\xaeV*\x95\xf7|\xdf7\x0c\xc3x\xa3^\
\xaf\x7f\xc8q\xdc\xadb\xb1x\xef4\xe0^U\x81|>\xdf\x02@b\xb1\xd8\x02\xcb\xb2o\
\x17\x8b\xc5\xdfq\x14\xfeq\n\xd2\xe94_\xab\xd5\x9e\x12\x04a\x8ceY\xe28\x8e\
\x05\xa0\xb4\xb6\xb6\xb6\x07\xc0\xef\tn\x1b\r\x85B~\xab\xd5\x02\x00?\xf8!\
\x9dN\xf3\xae\xeb>\x93L&?\x9a\x98\x988/\x08\x02\xd14\xad\xb2\xb5\xb5\xf5\xd3\
\xe4\xe4\xe4\xd7\xeb\xeb\xebZ?\xf0\x7f\x9aa\x18\xa3\xf1x\xfc\xfd\xb9\xb9\xb9\
\x0b\xa9T\x8am6\x9b\xd04MZ\\\\|\xadP(\xec\xc5\xe3\xf1oN\x04\x13Bb\x8a\xa2\
\xbc\x13\xd4\x1a\x8d\x86\xcc\xf3|\x8a\xe38VUU\xb4\xa3B4\x1a\x8d\n\x82p.\x1a\
\x8d\x86\xfa\x82\xc3\xe1\xb0]\xab\xd5\x12\x84\x90\xcf\x82z\xa7\xd6766 I\x12\
\x18\x86A\xb5Z\x85\xae\xeb\xf0\xbc\xa3n\xef\x0b\x9e\x9f\x9fw\x01\x90\x07\xf5\
d29&\x8a\xe2uA\x10^\x8cF\xa3,\xcb\xb2\xa8V\xab\xd8\xd9\xd9\xd9w\x1c\xa7xxxX\
\xff_9\x1e\x1e\x1e\xd6M\xd3\xfcTUU\xe9\xe0\xe0\xe0I\x9e\xe7\xcfX\x96e\xda\
\xb6\xfd\xb3m\xdb7t]\xef\x0b&\xedA\x033\x05\x8ej}ff\xe6\xcf\xe9r\xf9\x83g\rc\
\xef\x1e\xc3$\xf6\x81\xb3\x9f\x84B7UU=\x00\xe0?\xd4 \x01\xa38*\xb3\xe0|\x9c\
\x96\xb7\xf2y\xfa\x9c\xef[\x83<o=N\xe9\xf7\xe3\x94&J\xa5\x92\xd1>\xfbp\xe7\
\x01\xe0;\x8bH$\xd2\x00p\xb9=:\x1e\x0f\x00\x80\x94H\\j1\xccv\x18\x00CH\x8c\
\x05\xfe\tBz\xa5\xa2\xf3\x84Q\xc7q.\x01Xh\xef\xaf\xb4\xc1\x89\\"\xf14\x80\
\x1fY\xe0%\xeay\x1f\x03\x80Gi\xd7%s\xadVK\x02\x90i\xef\x17\xdak\x1b\xc0\xab\
\x01(\x00\xfc\n\xe0\xcaW\xf1\xf8\x1c(}w\x90a\x06YB\x96Z\x94\xa2\x05\xfc\xc5\
\xf8\xfeZ\x17\x98a\x98f$\x12\xb9\x01\x00\x8e\xe3\x90\xc0\xfa\xcd\x1e\xd1`\
\xdf\xf3\xeeN\xf0<\xf5\x00\xe2S\n\x9b\xd2\xdb\x0c\xc3\\{\xfe\xce\x9d\xdb]\
\x07\x15EQ{\x01\xdaag\x02\xfbN\x9e\xe3\xd9\xb1\xb1\x0b9Y6s\xb2\xac\xe6d\xf9|\
\xcf\xbf{\x80\x8f/4\x12\x89Pt_\x1e^\x07x\n\x90\x9b\xa3\xa3\xe7r\xb2\\\xa4=\
\x1a\x08\x00\xfe\x05\x05\x11\x9b\xd3$\xd2\x1f5\x00\x00\x00\x00IEND\xaeB`\x82\
' 

def getMoveLeftBitmap():
    return BitmapFromImage(getMoveLeftImage())

def getMoveLeftImage():
    stream = cStringIO.StringIO(getMoveLeftData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getMoveRightData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03VIDAT8\x8d\x9d\x94=l\x1bu\x18\xc6\x9f\xd7\xbe\xf3\xf9\xfeNk\xc7qQ\xe3Z8A\
M\x8b,GQ">\xa4\xf0\xb1\xa5\xba$[\x83@\xaa\xd8`-H\x0c\x0c\xc0\x00\x13\xb4\x0c\
\x0c\x85\xa2\x82*T!\x18\x80\tDcR)E\x0c\xd4B\x0c, \x86\x8bu\x89Oq\x13\xe3\x04\
\xee\xae\xaf?\xce\xf6\x9f\xc5F\xd1Iv,\x9e\xe9t\xcf\xfb\xfc\xde\xbf\x9e\xfb \
\xc30\xacB\xa10\x85\x80fgg\xc7\x13\x89\xc4\xad\xe9\xe9\xe9\xc5X,F\xb6m;\xd5j\
\xf5\n\x80[\xc5b\xb1\x1e\x9c\x0fJ\x19h(\xca\xfbkkk\x17\x16\x17\x17\xb5v\xbb\
\x8d\xed\xed\xed\xe4\xc6\xc6\xc6\xdb[[[[\x00\xee\x8c\x02\x8e\x19\x86\xf1b\
\xd0h\xb5ZO\n!";;;h6\x9b\x08\x87\xc3H\xa7\xd3If\x16\x00\x08\x80\x1c\n&"\x15\
\xc0\xe7AC\xd34\x94J%yxx\x88p8\x0c\xcf\xf3`\xdb6\x98\x19\x00B\x00:C\xc1R\xca\
\xbf\x0b\x85B"h\xcc\xcf\xcf\x7f\xa6\xeb\xfa\xa5T*\x15QU\x15\x8e\xe3`ww\xf7\
\xd0\xf3<>\xee\xb4\xc0\x90\x8e]\xd7}\xd5\xb2\xacL\xadV{\\Q\x14\xbd\xd1h\xec1\
\xf3\x8dP(\xf4#\x80\xee\xff\x06\x9b\xa6\xe9\xe4r\xb9\x17*\x95\xca\xb3\xae\
\xeb"\x97\xcb\xfd\xea\xban\xd54M\xff8(\x00\xc00\x0c\xeb\xb8\xe5\xba\xaeWF\
\x82\x1dQh\x84\x19"\xa2\xd3\x03\xb21]\xd7\xff\x02\xb0\x02`E\x08\xd1\xef>2\
\xb0\x8a\xa3`f~\xbdw\xdd\x9fo\x03\x88\n!<f^\x05p\x1b\x00\x98yU\x08!\x99\x99F\
\x01\x87\x84\x10W\x99\xf9\x17\x00\'\x00<\x04\xe0[\x00\xcf13\x05fo3\xf3j<\x1e\
\x1f\x1f\xa5\x8a\xff^-!\xc4w\xba\xae\xdf\xec-\xfbxhj\x84\x877H\xa2\xd7\xe9\
\xca\x91{\xfd\x9e\x1f\x1e\xa5\x8aAj0\xf3\xb8\x10\xc2f\xe6\xe7{\x9b\xbeg\xe68\
\x80\xc6(U\x0cR\x17\x80{\x82\xf9\x91/\'\'\xcf~\x93N?v\n\x98\xbc\x0c4%\xe0\
\x0f=\xf1\xdc\xdc\xdc\x99L&#\xc6\xc6\xc6h\x7f\x7f\xbfS.\x97\xab\xa6i:}\xffn6\
\xab\xfa\x9d\xce*\x01W\x88(\xfai2\t\xd6\xf5\x0f\xa8Vk\x0e\x02S>\x9f??55u}fff\
>\x1a\x8d\x864M\xf3\x88\xe8F*\x95\xfa\xb0X,\x1e|\x05\x84\xfdN\xe7e\x10]\x13D\
\x08\x03p\x80w\x84\xae?\xf89\x93\xb9>\x08,5M{kii\xe9\xa9\x85\x85\x85\x88\xef\
\xfb\xd8\xdb\xdb;\xb9\xb9\xb9\xf9\xca\x99{\xf7~z7\x9b\xfd\xb3+\xe53R\xcak\
\x04 \x0c\xa0\xf7\x9d\xdf\x95D\xe7\x1d)u\x85\x88\x12\xcb\xcb\xcb\x97\x82\xe4\
V\xab\xf5\x04\x11\xa9\x96e\xc1\xf7}\x10\x11\xe2\xf1\xf8\xc9\x0c\xe0G\x81GU\
\xa2T\x17x/\x04\\\x94D\xe7\x9cN\xe7\x8e\x04^\xbb`\xdb\xbf\x13 \x15)\xa5OD_\
\x04\xc1\x91H\x04\xa5RI&\x93I(\x8a\x02\xc7q`\xdb6\xb2\xbe?\xd1\x96\xf2\xa6\
\x04R\x12\x00\xa4l\xb4\x81\xaf\xbb\xc0\x1b\x86m\x9b\xfd\xbc\x02\xe0\xc1\xfa\
\xfa\xfa\xa9 8\x9f\xcf\x7f\xa4(\xcaK\x13\x13\x13\x9a\xaa\xaap]\x17\x95J\xa5\
\xfa[\xb7k\x9f\x93\xf2b\x7f\xae\x1d\nU\xbb\xcdfm\xe5\xfe\xfd\xea\xd1\xfc\xb0\
\xff\xf1\x9b\x96e\x9d>88xZ\xd34\xf2<\xef\x9fz\xbd~\xf5\x87z\xfd\x8fO\xca\xe5\
\xc6\xa0\\_\xff\x02\x90\xbfd.cn%e\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMoveRightBitmap():
    return BitmapFromImage(getMoveRightImage())

def getMoveRightImage():
    stream = cStringIO.StringIO(getMoveRightData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getMoveUpData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x04NIDAT8\x8d}\x94]h[e\x18\xc7\xff\xef{N\xf3q\x9a\x9c\xb4f\xdd\xa0MV\xd7\
\xa4\xab\x9b\xe2\x07\xbb\x10\xbcH\x17F\xb7l\xdd\x85W^\x88\xe8\x85\x88\x03\
\x15\xe7\x85\xb2\x89\xe8\xc5\xf0B\x04\x85z5\x10D\xc6` \x88\xa8[lA\\{\xa1\x14\
a\xecbt\xd2\xa5kr\xd2fm\xb2\xb6I\xce\xe9Ir>\xde\xc7\x9b\x93Z\x9b\xb6\x0f<\
\xbc\xcfy8\xfc\xde\xe7\xf9\x9f?\x07\x99L&\x8f\xff\x87\xd4.\x14E!\x00\xe7\xbc\
$\x00=\x00$\x02\xd8\xd4\xc0\xc0\xf0d,6G\x00\xc3.\xc1w\xe9\xb9\xdeI\xa6i\x8e\
\x03\xb8\xe5\xe5\xb8\xa2(\x1bA\xe0\xd0\xd4\xe1\xc3/\x11c\x7f\x03P\xa6b\xb1\
\xa7w\x03\xcbB\x88no"x\x80v\xfd\x9a\xf7\xdc\x8e[\x92$]\xbc\x1c\x8d\xa6!\xc4\
\xe7\n\xe7\x11\t\x88\xb8\xc0\xf5\xc9\x81\x81/\xc1\xd8\xdd3KK\xf7\xb6&\x16Bt)\
\x8arSQ\x94\x9b\xde\xfa\xed\xda\xd99\x85a\x18\x07\xa3\xb2\xdc\xeb\xe9E>\xc6\
\x10\xe1\xfcYU\x92\xae\x059\xffj2\x16{f\x0b,\xcbr\xd54Mf\x9a&\x03\x80m\xf5\
\x8dm\xd3\x03\xc0G\xc1`\xf0\xe3\xb7WW\x7f\x04c\xef\x19DF\xd5u\x1f\xd9D\x13]\
\x8cAel,\xc8\xd8\xc4\xd4\xc0\xc0\xf0^\x1a\xb7\x83\x01\xb8\x89\xff>\xde\x17\
\xde\x85\x8f\xcf\x14\x8b\xbf\x10\xd1\x1b.P\xad[\xd6\x15]\x88\t\x07\x80\xca\
\xf9\xa8O\x92\xaeM\x0e\r\x1d\xdc\x0f\xdc\x86\xff\xe5i\xcd\xbc\xb4\x00\xa0\
\xb6\xb4\xf43\xe7\xfc|\xfa\xd1\xa3\xc7\xe0\xfc\xb3\x9a\xeb^\x15\x00g\xc0\x8b\
\xb2\x10Ay\x0f \x1f\x1e\x1e~R\x92\xa4c\x8a\xa2\xb0V\xabeY\x96\x95\xeb\xef\
\xef\xd7\xa6\xa7\xa7\x1d\x00x\x05p\xa1i\x0f\x01 ](T\x01\\\x98\x8e\xc7G"\x9c\
\x9f\\w\xdd\xfb\x1d\xe0\xd1\xd1Qyuu\xf5\xa9\xfe\xfe\xfe\xcb\xc9d\xf2t$\x12\
\x91K\xa5\x92\x99\xcf\xe7\'+\x95\xca\x04\x80\xbb{\xadGD\x9b\xdeZ\x9d\x13\xe7\
\xf3\xf9\x03\xbd\xbd\xbd\x17N\x9d:u>\x9dN\xabB\x08T*\x95\x9e\xdb\xb7o\xbf<;;\
\xbb\xb6\x1f\xd8\x01\xe6\t\x18\x17\x00d\x00j&\x93\xb9\xe8\xdd\xd8ED\xb6\xe38\
\xa3\x81@\xa0\xbbX,\xc2\xb2,p\xce\x11\x8dF\xc3\xa1P(\xb1\x17\x14\x00\x881\
\xb5]\xcb\x00\xc0\x18\xfb\xda;\x01\x00\xb6m\xdf+\x14\nh6\x9b\xf0\xfb\xfd0\
\x0c\x03\x9a\xa6\xa1\xd5j\xed\xc7\x05\xb6\xb9L\x06P\xcff\xb3O\xb4\x1bG\x8e\
\x1c9\x14\x0e\x87/-,,\xc4u]\x8f\xf8\xfd~lnnbee\xa5V\xaf\xd7\xff\xd9\x8f*\x88\
$\xf2\xe8\x1d\x1a/..\xae%\x12\x89o5M\x8b\xd6j\xb5\xd3\x8a\xa2\xc8\x86a\x98\
\x86a\xfc\xd6l6o\xec;/c!\x00 "k7\xbb9\x0b\x0b\x0b\xf7\x87\x86\x86>i4\x1a\xd7\
8\xe7\x92\xeb\xbaM"z\x18\x8f\xc7K\xf3\xf3\xf3{s\x89\xc2\x00 \x80\xd2\x9e>\
\x06\xa0\x86B\xa1\x03\xa1PH2\x0c\xa3\xa9\xebzeyyY\xc2.\xff\x90?c\xb1`\x83(\
\xdd\xcb\xb9\xbfN\x04\x17\x98\xe9\x00\x9f8q\xa2K\xd7\xf5\xe7\x13\x89\xc4\xa5\
\x91\x91\x91\x93\xaa\xaa\xca\xa5R\xa9\xf1\xe0\xc1\x83\xdf\xd7\xd7\xd7\xbf9~\
\xfc\xf8\x9d\xb9\xb99\xab\xfd\xfe\x1f\x83\x83\x81\x06cGU!\xc6$\xc6RD\xf4\x1d\
\xf7\xf9>\xe8\x00\x97\xcb\xe5\xbe\xbe\xbe\xbe7S\xa9\xd4X*\x95\n\xbb\xae\x8b\
\xb5\xb55ufff|vv\xb6\\.\x97\x97\xb2\x83\x83\xb2mYe\x00`\xc0s*\xd1;2c\xafV\
\x85\xc8\x9aB|zN\xd3j2c\xac\xe7\xec\xd9\xb3\xafo\t\xec8a\xd7uS\xb2,+\x85B\
\x01\xb6m\x831\x86H$\xd2\xad(\xca \xe7<\xc4\x84\x88G%iD\xe6\xfc\xa8\x00.\xd8\
D\xc7\x1a\xc0\x0f\x82\xf3\xf7\xcf\x15\x8b+\x00 \x13\x91\xcd\x18\xfb\xbe\r\
\x96e\x19\x96e\xdd\xd9\xeec]\xd7w\xfa\xf8\x8a\xcb\xd8\x0b\x82\xa8D\xc0O\xa6\
\xeb\xbe\xebH\xd2\xdd\xf3\x85\xc2\xc6\x16\x07\xc0f6\x9b\xedk7\x92\xc9d_ \x10\
\xf80\x97\xcb\r\xe9\xba\xde\xe3\xf3\xf9\xda>\xde\xa8V\xab\xf7l\xdb\xde\x90\
\x88\xdej\x125\x99\x10-W\x92\x8c\xcc\xf2\xf2\xfaNI;4\xce\xe5rk\xc9d\xf2\xaa\
\xa6i\xbd\xd5ju\xbc\xbb\xbb\xbb\xcb4M\xa3^\xaf\xff\xea8\xce\xf5\xc5\xc5\xc5\
\xc7c\xc0j\x87\x8fv\xc4\xbfQ\x80\x08\xeaK=\xe9m\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getMoveUpBitmap():
    return BitmapFromImage(getMoveUpImage())

def getMoveUpImage():
    stream = cStringIO.StringIO(getMoveUpData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getNewData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x02DIDAT8\x8d\xa5\x93=kTQ\x10\x86\x9fw\xee\xeeJ\x12\xa2\x92\xafu\tX\xa5\x12\
\xdb`\x92_`c%\x16vbk-\x82\x98F\xfc \xf8\',l\xb4\xb1Ia!\x8a \xa8\ti\x8c(\x88&\
EB\x88\x06R\xc8\xb2&\xd9\xdc;\x16\xf7ss\xd7lB\x06.{\xce\xb0\xe7\x99\x99\xf7=\
\x07N\x18\xee\xc8\xbf\\\xab\xb9\xa3b>\xdb<\x9e{x_b\xf68PS\xc4\xf0\xd9\x1d\
\x1a\xa3M\x02svw\xed\xe9\x95\x99\x1f\xb74>\xdf\xaad\x15\xc4\xec\x9d\xdbw\x8f\
\xd1i\x1b\xda_\x89Zoh\xfb0N?\xdb\xbf\xbf\xdd\x08+\xd5\xb7\xfe\xfd\xf2\xf3\
\xca\xc1\x03\xab\xab\xab\x04A\x80\xbb#\tII\xe1|\rNU\x1b\xf4\xdbk\x82j\x1f^\
\xbb\x8a\x82!N\x8f\xbc#\x8c^\\\x0f\x07\xf7\x97\xec 8\x05\xa4\x10w\x07w\xdc\
\x1d\x8f\x1cw\x80\x10S\x13i\x17\xd7\x08\xd8\x10`\xc0)\xf0\xa8_fgz\x82Q\xac\
\x93$d\xc2\x0c\xa4\x80H\x83D\x8c\xa2\xfd\x15h\xbf\x87\xe8\x17{;\x0b\x987\x97\
\xab\x16n\xff\x17lf\xf1\xaf\x84dy1\x19\xa6\x80\x88s\xec0\xcd\x9eO\xc0\xde"\
\x95\xf6KV~\xae\xe3\x84\xcf\xd0\xfeFI\xe3\x14\x9ai\x8c@E\x8d\x05&D\r\xd78m\
\x86\t\xb9@\xdf@\x95\x85\xe5?LN\xac}\xa6\xfe\xeao\xa9\xe3\xc5\xa5\x85N\xb3\n\
\xddg\x1f\xe9\x14\x01n\x03xp\x1e\xd5.\xd2lU\xd1\xf8|K\xc2K\xe0K\x93S4\x1a\
\x8d\x03\x9a\x92\xcbaJ\xf6\xc9t\xb2x\xaa\xcc\x908\xbaJ\xb1\xb9\xb9\x19\x1fr\
\x8be\xc8\xc6\'\x9b"\xf1\x94\xe4\x0f\xa5\xe8\nN?\x97g\xddu\xc8S, Q\x1a\xbb\
\x1b8;\x04XbV\xac)\xc8\x92}\x9aO\x9a\x8d\xf3\x9dQ*\xf6\xf1\xd3\x87RGR,E\n-j\
\xac\xd4\x84^\xe0\xe9\xa9\x19\xc6\xc6\xc6\xf2;l\x89\x89Xb\x9c\x10\x86Y\xf1\
\x96\x94\xc5\xe8\xaa\xf1\xd6\xd6V\xc7u\xa3\xa0-(+P\x9c\xac\'\xb8\xb3\x8a\x15\
\xccK\x801-\xcfq\x0cp\xd6\x8d\xe5\xc6%\xbc\xd4\xca\xfc5\xba\n\xf7\xf8\x88\
\x1dg\xae\xa7O\x9bN\xe3\xe2)8Z\xc7\xf5z\xfd\xb0ZG\x8e\x0c\x1cE\xe1\x83\xb9\'\
\x8f\xee\x9d\x04\xb6\xb6\xbeq3]wy\x8c\x87\xe6{\x85\xa7\x8b\x7f_\x88\x98\xd9\
\x9b\x9d\xb4\xe7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getNewBitmap():
    return BitmapFromImage(getNewImage())

def getNewImage():
    stream = cStringIO.StringIO(getNewData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getOpenData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03\x84IDAT8\x8d\xa5\x95Al\x1bE\x14\x86\xbfY\xaf\xed\xb5\xd7n\xe2\xa4u\x1b7\
\r\x94\x06QHZ\x8a\n**HHH\\9T%\x12\x07\x14!\xc4\x19\x90*n\x80\x04\\\xe9\x15\t\
\x0e \xa2\x00U\xa1\x11\x12=\xf4\xd0\x03\x07P\x0f\xb8!FN\x13JI\xa3F\xb6\x1b;\
\x96\xe3l\x9a\xc4\xbb;\x8f\xc3\xda\x9b\xa06\xa1\x85_\x9a\xd1\xec{3\xff\xfc3\
\xef\xbdY\xc56\x18\x1b\xfbrD\x0c9\xe7{>\x82l7\r\x00\x85B\x10D\xf3\xf1\x1b\
\xaf\xbf\xf9\xde\x8e\x93\xcf_\xf8F\x1e\x04\xcdfS\xbe\x1a\xff"T`\x8e\x8e\x8e\
\x1e\xf7\xb4{Q)\x03A\x14\x18\xd8\xc9\x84\xe1\xb9>\x00\xbe\xef\x01j[\x01Zk\
\x00<\xcf%\x16\x8b\x85v\xb3\xd1\xa8\x7f\xf6\xd6\xdb\xef\xec\xdd:\xf9\xf6b\
\x99\\n?\x00\x93\x93\x93\x94\xcae\x0c\xa5\x02\xfePS\xf0\xa1E\xc8d\xba\x19\
\x1e\x1a\x0e7\x010\xb5\x88\xe78\x0eW\xf3y\x00\x92v\x92\xfe\x81\x1c\'\x9f}\
\x8eF\xa3\xce\xe0\xe0 \x87\x0f?\x86aD\x02"-\x88H8\x06\xc14MJ\xe5\n\x9e\xe7m!\
\xf6\xf5r\xdc\xea\xa2\xb7w7\x00\xbd\xd9nN\x9ex\x9e\xd5\xd5U\xe6\xe7\xe7\xf95\
\x9f\xc7J$\xb6h$$\x88\xc7b<40\xc0\xd0\xd00\x8b\xd5\n\xa9Tj\x93XE\x94\xbd\xb1\
\xb6\xecZ\x96\x15]\xacV\xd8\x95\xb1I$\x12\xcc\xcd\xfd\x89\xeby\x1c9:\x8c\x92\
\xe0\x8e\x95\xa1\x10-(\x03\x94Rh_\xc8\xee\xdd\xc7\xcc\xec,3\xb33\xf4\xf4f>\t\
\x89\xadD\xbcP\xb9]~&\x99\xb0\xb1S)^|\xe1%j\xb5*\x7f\xcd\xddd\xc5Y\x01!H7\
\xad\x91N\x18\r\x85iFHX\t\xb2\xd9,\xbf\x17\xa7\xc8\xf4d\xce\x9ez\xf9\x953a\
\x04N\x8f\x9cz\xf7\xd8\x93\xc7>\xe8\xef?\x90\xb4\x92Q\xba3}|}\xa9\xc0tc\xcf\
\xb6\x99\x00`E\x82\xacY\xf7#w\xf9\x1e\xb5+WL%\xea\xe6\xd2R\xdd=x\xe8a\x9e:\
\xfa4\xdf\xffp\x91\xd7^\x1dA\xa9v\x8a)\x05(\x94\nZ\x1086\xfd\xf7\xc0\xd9\xcf\
\xcf?n*%\xf5V\xcbu}\xdf\'\x9dNs\xe5\x96\xc5\x91\x96f\xba\xb4\xba\xa3\xe2\xed\
\x90\xcbX8\xeb\xe2\x19nT\x8a\xd5\xea\xa2\xeb{\x1e\xa5J\x89XD\xffk\t\xef\x84\
\xe5\xa5\x9a\xac\xfb\x91\x05cb|\xa2lY\x96\xa4\xd3]8+M\x8e?\xb1\x1f\xf9\x8f\
\xbc]\xc9(\xabk-=\xe0\\>c\x00\xac4\x9b\x1bZ<\xbe\xfd\xf1g\xfa\xb2\xbd4\xd6|D\
@\x8b\xa05h-\xedF\xbb@\xb6\xfa\x08\xed\xc9x\x84\x85J\xd5u\xa3R4\x01l;\x99\
\xbfq}\xee`_\xff!R{\x06(5Z\xac{\xed\xf2lW\x99\xb4\xdf0:#\xd5\xf1\x05\xe8IE\
\xf1|\xa10}\xe3\xd6O\xe3\x13e\xb3\xbdv\xd2q\x9c\xd3\xfb\x1e9@\xdd\xf1(\xd776\
\xcf\xa7\x04$x\x16U{\x1c\xd8\xda>\x00Q\xb4|\xe1j\xbe\xe0f\xef\xfc\xf2\x11\
\x80\t\xc4\x17\x16J\x85\xf4\xae\xb4>\x91\xcb\x1a\xc5EoSm\xb0*\xec;\t\xd6\xd1\
\xde\xf1e\xbb\xe2\xb8\xbe\xe6\xdat\xa1z\xf9\xdc\x85\xb1\x0e\xf1\xeeb\xb1h\
\xf7\xe5\xfa\x8cK\xd7\xee\xdc\x1d\x11\t\xae\x81-\xbd\n\x95\x06>\xcf\x13\xa4Y\
\xf1\xd5Z\xe5;\xc0\x00\xb4\t\xac\xd4j\xb5?\xa6~\x9b\xfc\xd0NM\xbf\x7f\xff9\
\xf0O\xb8\xb5\xd9\xebS\x13\x9f\x8e\x03)\xa0\xd99\x9d\x05$\xdb\xc6T{\xd7\x07\
\x81\x00-\xe0\x0eP\x07\xd6\xeeU\x97\x06;\xfd2v\x86\x86\xffQ]\xf7\x83\xbf\x01\
\'.\xdfW\xda\xa1\xb5O\x00\x00\x00\x00IEND\xaeB`\x82' 

def getOpenBitmap():
    return BitmapFromImage(getOpenImage())

def getOpenImage():
    stream = cStringIO.StringIO(getOpenData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getPasteData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x02\xc5IDAT8\x8d\xa5\x94\xcdKTQ\x14\xc0\x7f\xf7\xcd\x9bA\xcb\x1a\x9b\xf1\
\xabD\x08\x14#wa.\x82\x08\xfbp\x06ic\xd6\xd2\xf0\x0f\x88\xda6-B\xa6D\xda\xa4\
\x8b@\x88h\x11\xb9kS\x8bt\xa9A\x0cA\xba\x90 (\x08\xa2\x0f\xd4\x99\xd2y\xaf\
\xe7\xe8L\xe3=-f|\xf3\xe1\x8cR\x1dx\xbc\xf7\xee\xb9\xe7\xf7~\xf7\xdc\xcbS\
\xec\x11CCC\xb3@o\xd9\xf0\xdc\xd4\xd4\xd4\xd9\xdd\xeaT\xf1\xcb\xc8\x08\xc6\
\xe79|\x00\x99\xa6\x81\x13fM\xdd\x0b\x11\x1a\xbb\xbb\x8f\xa1Tn\xaa\x88\xb0\
\xb0\xf0\x01\xa5Hd7\x9dA_\xfc\xf9<\xc0\xd1^2\xd1(z\x07\xf8\xfa\x05\xe3*J\x1e\
\xe8-\xea\x006\x03\xa7\x8c\xe6\xceS\xaa\xad\xad\xb9\xa2\xd1\xb7o\t\x96?\xc6\
\xa4\xe6gL\x0b`\x188zK]\x9f\x9c\xd5O\x01\xccm\xd3dL&.\x9di\xf7\xaf\xfcn\xe2\
\xad\xdd\xc5\x86\xbdE0\xd8H{{\xa7\xeb\x90\x93\xce\xdd\xd3iX^>\xa6j[\x8f{z\
\x0e\xbe\xc7\xcf\x8a\xffe\xec\xd38P\x00\x7f\x9e\xc3w\xd0\xa4\xde\xeb5\x98_\
\xed"r\xfb\x1eV\xd2b|\xfc>\x8b\x8b\xef+\x1a\x1f8PG$r\x8bC\x81C\x8c\xdd\xb9\
\xc9`\xcb\x0fDT\x03\x08.\xd8\xed\x8b(\x9c4\x04\x03AL\x8f\x87\xd1\xd1Q\xb2\
\xd9lE\xb0i\x9a(\xa5\xf0\xfb\xebIeT\xe9f\x95\x83\xcbC)\x85\xd7\xeb\xad\x9a\
\x17\x91\xa2\x97=\xc0\xc5\xf9\x99\x99\x99]\xa0\x10\x0e\x87\xaa\xe6w5\xee\xef\
\xef\xaf\x00\x94\xfc\xa5\xd1ZW\xa8\xaa\x06.R.7.@\x05\x10\xfa\xfa\xfa\xfe\xcf\
\xb8`\x98\xbbo\xc3m\xdb\xa2\xa9\xa9eopY\xff\x99\x9e\x9e\x01\xa4d\xf9\xa1P\
\xc8}\xb6\x7f\xd9Uk\xcb\x8c\x0bi\xad5\xe1p\xa8\xc4P\xeb\\_\xb7\xc7\x12\xf1D\
\xd5\xd5VmE1\xa0\xb8\x15KK\xdfq\x9cuR\xa9\x14"\x7f\xb3y\x15\xc1:o,|\xf9\xf2\
\x95\x81\x81\xcb\xee<\xcbJ\xfe-x\xab\x04\xea\xb6"oiYIl\xdb\xc6q~\xfd\x8bqa\
\x93\xd6\x1d\x87x<\x8e\xe4\xcf\xaem\xdb\xac\xac,\xf3\xe8\xf1#.\xb6,T\x07oo\
\xdb~\x9f&\xf1#\xc1\xe1\xc3\xad\xee\xa4\xd6\xb2"\xcbJ\x96@\x83\xbe\xf5\xbd\
\x8d\xdb\xf4;\xc6\xeeFHe\x8cj\x8bq\xe3J\xeb\x1b\xf6y2\x15s&\xc0\x93W\xa4o\
\x9cg\xd5\xd9\xc86\x9e<b\xd1#\xafK&\x95\x9f\xd1\x1d\xa1 \xe9dA$^4\x94\x8bk\
\xe7\xb8\xa4\x0cc\x12-\x8dy\x98\x9bS;\xff\x8a\xb9\x0fJ\xe1\x9b\x82Z\xd3\xb5\
\xcd\xa3\xb5\x9d\xa7\x1fNL<\xdb\xd8Q0<<\\c\x9ai\xbf\x88\xa7\x1et\xc00T\x10h\
\x00\t\x88P\xa7\x14\x1b I\xa5\xd4\xaa\xd6\xfa\xa7\xd6\xb2\xa6\x94\x99L\xa7\
\xd5ZGG\x87\x13\x8dF5\xc0\x1f\x86\x9e\x98\x8c\xd8_7\xea\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getPasteBitmap():
    return BitmapFromImage(getPasteImage())

def getPasteImage():
    stream = cStringIO.StringIO(getPasteData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getRedoData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x02\xdfIDAT8\x8d\xad\xd2\xdbK\x14q\x14\x07\xf0\xef\xf9\xfdfv\xdd\xbc\xe5Z\
\xab\x82\x91\xdaC\x17D*\x8c\x10\x92\xc2.x\xc3\x87 "\xe8!zX\xa1\xbf\xa0W\x9f{\
\x08\n\x02\xa5\x08\xa2\x97\x9e\x04\xb10\xac\x87\x051z\x88p\xc1H\\\x17*\\wU\
\xdc\xf5\xb6\xbb\xbfq\xe6\xf7\xebeGfg/Y4p\x18\x98\xf3\x9b\xcf9s\xe6\x00\x7fy\
\r\x8dy\xd4\xd0sT\xff\xe9\x1c\xfb[\x18\x00 =[\x03\xcfP\xf7\xdf\xe1K\xbd\x1d\
\xe0\x9ag\xa3\x1c\xfeo\x1d\x1f\x00\xa7r/_\x7f\x85\xca\x8a\xac\xf7>A=q\xa3[{\
\xab\xa8\xd1\x03\x98\x99\n\xc32\r\xff\xdb\x07H\x1e\x08\x1e\x1c\xf5\xf41\xc2\
\xbb>\xbd)l]l>\x93\xae\x12\x9a\x9d\xdb\xdb3\xb1cl@lK466\x16\xc5\x8b\xc2\x83\
\xa3\xde\x1b\x8c\xd4\xfb\xc1\x9e.\xec\xfa,l\xa6\x920T\x06\x8c\x11H#\x18B\x80\
i\x84d|\x17\xc4\x80\xd6\xd6V\xccL\x85!\x95Q99\x8ctQx\xe0\x85\xb7\x8d[j\xe9\
\xea@\x17\xf6T\x1ak\xc9\xf8~\x0b\xd2T`\x9c\xa0t\x01\xb1\xad v$(\xf7\x97l|s\
\xd9\xd0C#057\xccL\xf9\xb4\xfb\xc2)A \xefjr\x05\xca\xca\xcf[$\xa0q\x82)\xe4\
\xfe3\x1b\xb5L\xc3\x1f\x1a\x81\t\x00\x050\x11\xf5#\xe0E|\'\n\xce\x19\xea\xeb\
\x1a\x000\xe8\xe4\x85\xca\x9dQ\xb0\xb0%\x17\xe0\xa9$47\xb6\x14\x9dq\x01\x0c\
\x00:\xf9\xc0IC\xed\x91\x1a\xe8\x894>~Z\xcc\xcb_\xe9\xef\x84V\x81\x92(Pr\x8f\
\tU\xb5>$Vc\xea\xc3\xecbJ*\x9c\x9e\x08\x1a4\x114\x08\x008\xe9e\xd1\x920\x87\
\x86\x06\xd6\xae\x16fS\x16\x81nM\x0e\x1b\xdf\x9dya\xedbf*\x0c\x0e~\xac\x18Zr\
\x14Y\xb9ey\xc0M\x00\xde\x931\xf1\r\xae\xed\xb1\xd1\xf1`f\xb9\xf8\x17\x17vLP\
*\xda<\'\xb7S\xd9u\x00\xc0\xa3\x11\xc4s\xe7\xc8.\x90N\xb3\xe3\xe3\xc1L\xcc\
\xf9\xac\\\xc7\x04\x80$\xd4\xe7\xf5\x8d\xb9^B\x87\xbdO\xdc\xf9\xc2D\xd0\xf0\
\xb8\x9aR\xae\xc8K\xda\x95Y6\xa6=\x9c\xce\xf2:\xcb4\x94\x96\xf5\xa4\xfa\x1e\
\xebwr\xb8\xe6\n=w\xe7\xee/rvC\xb9$\x8b\x86\xcc\xf4\x89k\xb4\x1a\xfb\x99\x1c\
:\xdf\xd3"W\x967.\xc7\xa3rL\xac\x81r\xe7\x9d\xc1\x1c\xa8\xdd}\x01\xbc\x1f\
\x8bS\xf2kk7\xff\x92H$\xef6\xf9\x0f\xfd\xf2\xb7\xcb\xdbM\x9d\x14\xf9\x11R1\
\x07f\x83<\x07J\xe78\x9cp^\x81\xc8\xb4\xb5T\xdf\xa2\xbd\x14\x9a\xa1\x83\x14\
\x11\xa3\xed\xc09&\xaa\x1b\xa4\xb9\x1e\x83\x80\xd8Gd\x11\x98\xc8\x05\xdb]8g\
\xc6:\xef\xa1\xfe\xe8Y\xed&q\nX\xa6J\xcc\xbf1_\xf3\x0c\xa4\xee\x85l;\x0c\xcd\
\xe7\x83\x9c\x9fG&\x12\x81i\x17q\xaf\n\x95\x08gq\xe7\xe5\xdc\x86\xbcQ\xfc\
\x06m\xa4K-)\xad\xde\xbe\x00\x00\x00\x00IEND\xaeB`\x82' 

def getRedoBitmap():
    return BitmapFromImage(getRedoImage())

def getRedoImage():
    stream = cStringIO.StringIO(getRedoData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getRefreshData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x04\xd0IDAT8\x8d\xc5\x95}L\x95U\x1c\xc7\xbf\xe7<\xef\xf7^\x10\x90w\x91\x17u\
\x0e\x05_\x02\xc1$[\x86Y[snn\xea\\\xa2\xe54\xd1\xad\x7fzY\xab\xad\xb5\xfehm\
\xcdZ[\xdaT\x866\x13\xb0Qk\xa5e\xb6\x9aCt:A\x14\x93\x100C\x91+B\xc0\xbdp\xef\
}\xee}\xee\xf3\x9cs\xfa\x83\x8b\xbcH[\xffu\xb6\xef\x9eg\xe7\xfc\xce\xe7\xf9\
\x9e\xdf\xbeg\x0f\xf0\x7f\x8e\xcd\x9b\xeb\xa5\xffR\xb7\xb2\xf2d\xee\x93\xbb\
\xea\x93\x00\x80\xccTP\xb2\xfb\xf8BE\xd5\xde\x06D\xb9\xc3x\x06\x17B\x91)\tRJ\
\x07\x18\x17\xe78g\xdfp\x98\x8d-U\x95\xf6#\xe8\xae\xba4N\xc5%\x87\x89\xf2\
\xeb\xc7*\xeeM\x03\x0bR\xb6\xef\xebj\x10l]\xbd<[]\x9c\x97*{\xdc\x1a(%\x88Fm\
\x84\xc26\xee\xf5\x8d\xb0\xeb\x9d\xdeP\xff\xb0)\x11\x82\x8f\x03T\xf9\xcc#Y\
\x94Di3\xe3b\xa1 ,\xa7\xa5\xea\xe5\x9e)\xe0U\xfb\xea\xbe\xcc\xcdL\xdc\xb2\
\xe3\xc5\xa5.\xcbf\xf0\x07#\x88sipi\n$\n\x10J\x00\x01\x80\x10\x04M\x0b\r-w#W\
\xda\xbcQ.\xf0`\xf5\xf2\xecymw\xfam\xbf\xdf\xcco\xaa\xde\xde+\x8fC\x8b\xf7|\
\xb5\xd2c\xa8\x9b\x9e/\x9d\xe7:X\xdf\xcc\x07\xfd&\xa5\x14\xe0\x8c\x0bA\x88\
\x93\x9e\xe4\x0e\x97\x16\xceu\x17\xe5\xa7KB\x00a[\xa0\xbct\xbe\xbe\xa2 K\xff\
\xb3g(\xee\xb9\x92\\\xd2\xda\xd5\xe7\xd8\\\xe2\x00@\xc7\xc1\xba$\xef\x8d\xf7\
\xa8\xee\xea\x1fZD\xc0\x8c\x12CW"\x8c\xf1\xfa+U\x154L\x91\xe6\x1d\x08\xad\
\xfb\xe9B\xe7\xb7\x1f\x1ek4\x9bn=\x10nM\x82w(\x8c\xe1\x90\x83\x92\x829D\x91)\
\x18\xe3\x90uk*XP\xf2BO\xdf(I\x9a\x15\xe7[\x90\x93q\xdd\x8a:>\x01\xb6\x1f\
\x00n\x1e\xda\xe6k9\xba\xad\xe9\xf2\xe1\x97\xb6\xda\x16{\xea\xec\xa5\xdb\xcd\
U\xdf5\x9b\x89\x06Ev\x8a\x0b\r7\x07\xa0H\x14\x9cqbMw\x0c.4C\xd7\xbc9sS\x8f\
\xc4\xbb\xf5\x1aBH\x17\x87\xea\x9b\x9e\x98\xe6\xea\x8aV\xdbv\xde\x1d\rE\xa58\
C\x81w(\x0c\x0e@W(\x1c\x0e\xa2\xc4\xc0\x8fz\xcc\xb80\x93\xe3\x8c\xcf\xe3\x0c\
\xe3\xb4\x15U\x07\xb9E\x8f{\xb2RF\xa7\x83\x8b\xf7\xd4,\x91)9\xb5oS\x89\x96\
\x92\xe8BF\xb2\x1bk\nS\xa1)\x12\x18\xe3Da\xcaT\xb0\x9e\x9e\x99w\n\r\xfc\xd4\
\xce\xf5|\xa6l\x8fAOd\x10\x81\xb3\x8cq\xd7\x81\xfa&Kp\x01!\x00\x01\x01\x08\
\x80\x0b\xa1ZN\x88\x03\x93.H\xc9\x9e\x9a\xbf\x01\xe2\x99\x91(D\x80P\xbenXM\
\xeep\x8f\xf6\x1b\xff\xf6a]v\xb4+Gw\x0f\x00D\xc8\x13{\x91P\xf7\xc1zY\x95)\
\x00\x02B\x80H\xd4\xc1{U\x8dV\xf7\xc3\x917\x9a\x8f\xec\xb8\x11+\xb5\xc6\xdc\
\x1fQ\x80DWY\xc1\xf2HR|4\xf1\xc6\x9d\xfbe\xbd\xfdCU\x00I\x9e\xd2\n@\x10]\x95\
q\xeef?\x08\x04\xca\xf2SP\xf7\xdb-\xeb^\x7f\xe0\xe0\xd5\xaa\xed5\xd3\xddI\
\xdc\x95&\xab\xfc\x90j\x04\xbf\x1f\t\xf3\x94\x91`\xb0RSd6\xbe>\x91\n2\xe6\
\xd2v8\xb2\x92\xdd \x00Zo\x0f\x08J\xc8\x92\x15\xaf\x9c\x9c\xfb\xd8\xb9%\xc43\
\xc6W\x8d\x06\xcc\x8a[\xdd\xbdo\x05BV.!\xe2\xaf\xf1\xe5\t\xc7\x02\x84\x00X\
\x96\x97\x80\xde!\x13^\x1f\xc5\xa7\xaf\x95\xeb\xb5\xbfv\xac=s\xe9vGie\xed\
\x01\xc6\xf8U\x08\xdaCT&s\x87|b\x18JBG\xb7w\x8d\xaaP1{\x96\xcb\xf6\xf9\xcd\
\xea\xc7\xc1\x00\x08!0\xc3Q,\x9e3\x0b\x96\xc3p\xad\xdb\x87g\x8a\xb2\xa5\x95\
\x05\x99\xae\xab\xed}oz\x07G#}\x83\x012\xe4\x0f\xbb%\x83 m\xb6\x0b\xf9y\xa9H\
Np\x93\x9a3\xad\x11\xc3\xb6k\x1f\x03S\nr\xf7\xe1(\xde\xf9\xa2\xc1/\x11\xd0\
\xf5O/P\x9f-\xce\xd1}!\x07L\x00O,\xca\x90\x0bY\xba\x87\x90\xb1\xfe\xd9\\\xc0\
q8\xfcA\x0b5?_\x0b\n\xcby\xfd\xfc\xf1\x9d\x91\x89N\xc5\x9e\x99\xc5\x1b\xdf\
\xbf\xdc\xe6\r\xf5\xb4\x9d\xdf\xd0\xf9\xcb\x81\xcf\xee\x87\xe2\x1f\\l\x1f\
\x9e?\x12\xb0\xdc\xb2Di\xbc[#\x1eC\x81\x10\x00\xe3\x1c\x013\x8a\xe6\xf6\xfb\
\xfctc\x87\x15\x1cz\xb8\xff\xda\x89\xbd\xb51\x9e\x00\xc0\xc6s\xac\x17\xbdZ\
\xe3\x0b\xf5\xb5o\xe9\xfc\xf1\xa3?\x00\x181\xe9\x99E\x1b\x96\xa5.Z\xbbU5\x12\
\x8b\x84\x04\xcd\xa3\xa9\xb6i9\x92\x10\x00\xb7\x02\x17\x07\xba.\x1c\xea\xb9\
\\w\x03@8&\x13\x809\x0e&K\xb7\x1f\xde\xf8\xfb\x89\xbd\xe7\x01\xe8\x00\xb4IRb\
\x92$\xf7l%)\xab0\xc9\xf4\xf5\xf9B\x03]>\x00Q\x8c\xe5\xda\x8aA\x03\xb1w1\xd3\
\xafI\x9a\x04\x1b\x97<\xf9\x981\xd91E\x018\xb1\xb9G\xe3\x1f<\xfc97\xf1\x0c\
\x8a\x83\x00\x00\x00\x00IEND\xaeB`\x82' 

def getRefreshBitmap():
    return BitmapFromImage(getRefreshImage())

def getRefreshImage():
    stream = cStringIO.StringIO(getRefreshData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getRemoveData():
    return \
'\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\x00[IDAT8\x8dc`\x18\x05\x03\x0f\x18\x919\xc2\xc2\xc2\xe7\x19\x19\x19\r\
\xf0i\xf8\xff\xff\xff\x85\xb7o\xdf\x1a\xc2\xf8,(\xa612\x1a\xbc\xae\x08``\xf8\
\xf2\x83\x81\xe1\xf3w\x06\x86O\xdf\x18\x18>}e`\xf8\x00\xc3_\x18D\xdf\xfe@\
\xb1\x80\t\xc3\n<\x9a\x19\xde\x7f\xa1\xbe\x17F\xc1`\x00\x00\x14\x1c0\xa2\x9d\
\xcd\xe32\x00\x00\x00\x00IEND\xaeB`\x82' 

def getRemoveBitmap():
    return BitmapFromImage(getRemoveImage())

def getRemoveImage():
    stream = cStringIO.StringIO(getRemoveData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getSaveData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x04\x13IDAT8\x8d\x95\x95[l\x14U\x18\xc7\x7fg\xf6:;\xbb\xed^\xd8v\xb7e)\xbd\
\xb0\x14\x01)%E\x8a\x17R\x13\x1e0\x81h\x0c\xbc\xe8\x8b!>P\x1e6\xf5\x02*&&$\
\x18.\xb1\x18Ry\x10\x8d\x89Q\x91\x07y\xf0\x015!\xc6\xc6\x18\x91&\x04D\x9b\
\xa2m\xc1\xa6\x14\xba\xa5L\xb7\xdb\xe9\xec\x8e\xb3;>\xb4;\xb6T(\xfe\x93\xc9w\
\xf2}\xff\xef\x7f\xfe\xe7;\'\x19\xc1\x1c\xec=\xb4\xef\xe3\xa1l\xf5\xb3c\xaa\
\x11\x9e\x9b\xf7:\x8bZ\xa5?\xdb\x1b\xf5\xf5vt\xbds\xf6\'\x1e\x02\xa2\xb4\xe8\
\xfa$\xd5t\xf6J\xdd\xc5\x9a\xe4\xaa\xfc\xf2\x8aJi\xd2\x14\xde\xa5e\xb24\x925\
\xb8\xab\xe7\x99\xb8v~P\x9b\xd2=u\xa1\xbe\xfd\'\x0f\x9e\xfe|1aGI\xf4\xfc\x1f\
\xd5_%\xd6\xb6\x05o\xf4\xf7\xb9\x07\xfe\xba\xee\x1a\xba>(\r\xdd\x19\xc7\x15\
\x08\x13\xf2\xba\xf1F\x1bB\x19\xbdXv3\xed\xdd\xb6}{\xe4\xd2\xc5\x1f~\xef\x7f\
\x90\xb0\x04\xf0\xcb\x80\xefHb\x89\xe3\x866\xf0\xdd\xb5M\xd1\x0b/vw\xee\x95\
\x9e\\\xd6\xb3\xcd\xc8\xdc\x9c\x1c\x1e\xb8j\xa5\'\xb3d\xb5)B\x15q|\x95\xcb<W\
\xd3\xeb\xbe|\xf5\xd8VeQ\xe1\x89i\xb9A2\xb5\xccS+F\xb7\x1ez\xed\xa3\xd3\x00\
\x87\xf7}\xf6\xed\xc6\xc4\xf0\xc1)uBh\x93w1r\xd3\x00T&VHQ\xc5\x18\x1a\x9fl<\
\xb9\xe8\x8c_x\xf3\x95\xaf\x97{\x8d_\xb3\xaau`n\xd1#\x0b~\xbc[\xc3\xf2\xd5\
\xcd\xf3\x9a\x82z/wFoSU\x9c\xb8Wn\xff\x89\xf7\xbb\x8e\x028\x01\x96\x96O}\xa3\
\x8f\xbbN\x1e~\xf7\xd8\x82\x9d\x9f\xee\xf8`A.\x17y\x8c\xe1\xc1n>=>\xcf\x07o\
\xbc\xf5\xfa\x11\xe0\xa8=\n\xed\xb6\xfb\xcfP0\xca\xf4\xf4\xccq5M\xb3?[L\xffw\
\xedp\xb9\xe7\xf1\x86\x86\x87\xd04\x8dh4J*\xd5\xded;\xc6*\xd6\xc7bq\x00\xa6\
\xb4)\xfc\x8a\xff?\x9d\x96`\x15\x8b\x00<w\xf0\x0bL\xc3\xe0\xcc\x81]\x00\x84B\
!\xd2c\xe9$pY\x02\x10\x88\x1d\xeb\xd75\xa3\xeb:\x02a;ml\xd9Bc\xcb\x16\xcaCQ\
\x00\xf2\xf9\xdcL\xd4\xb344m\xa2nM\x0b\x00>\xd9\x07\xc0\xe3\xadO \x10k\xedQ\
\x08\xc13UU\xd5\xf3\\}\x98j\xa3\xff\xca\xcf\x00\xdc\x1a\x1e\x04\xcb\xa2`\xfe\
MN\xd7\xc8fT\x00\x06\x7f\xeb\xa1\xab}\xb3\xdd\x93H\xd4\x00\xbc\r \xa5R\xedM\
\xb2\xec\xc3\xedv\x13\x89DlR<ZC\xe7\xee\r\xf4\xf5t\x13\x8eVQ\xb4\xac\xd99X\
\x94\x05#\xf4_\xbe@\xe7\xee\r\xd4T%\x01P\x14ev\x1c\x11R\xa9\xf6&\xa9(HVV\xc4\
\x00PU\x15EQP\x14\x05I\x92\xa8\xad^\xc9\x89=\xad\xb6\xb8$\x04\xfe\xf20\xfd\
\x97/pbO+\xb5\xd5+m\xbe\xaa\xce\x9c\xa2\xbc\xac\x9c\xa2 )\t\xc4\xdaGV\xad\
\xc60\x0c\xcb\xe9t\x90\xc9dPU\x15Y\x96Q\x14\x855\xc9fNu\xb4\xd1\xd7\xd3MpI\
\x9c\x1b\xbd\x978\xd5\xd1\xc6\x9ad\xb3-\xa8\xaa*\x85\x82I6\x9b\xb5\xea\xeb\
\xea\x11\xd0*\xe5\xf2\xb9Gc\xb1\x18\x81@@\x98f\x81\xe2\xec\x8d\x97\x1aTU%\
\x1c\x88\xd3\xf9r\x0b}=\xdd\xbc\xf7R3\xe1@\xdc\xae\x01\x14\n&\x08\x08\x87\
\xc3"\x91X\x86\x9e\xcb\x07\x9c^\x8fwG2\x99\xb4\x9f\xcb\xfd\x10\nm\xe4\xfb\
\xe3\x1b\xef[/\xa1\xb1\xb1\x11\xd9\xeb\xdd\xed\x04\x18\x1b\x1bc||\xfc\xbed\
\xabtq\x0fQ\x8bFg\x9e\xa6\xb3\x940\x0c\x83H$\xc2\xb9s\xe7\xf0x<(~\x1f\x01\
\x7f\x19\x92$!\xcb2B\x08dY\xc6\xef\xf7\xa3\xaa*\x15\x15\x15\xa4\xd3\xe9\x05\
\xb1$,\xcd\xdd\xcd4M\x1c\x0e\x07\x96e!\t\x07\xf9|\x1e\xc30\xb0,\x0b\x97\xcb\
\xf5@\xe7\xf7\xc2v,\x84@\xd7u\xd6\xafo\xc24\x0b8\x1c\x0eL\xd3\xb4\x89n\xb7\
\xfb\xa1Em\xe1\xd1\xd1Q+\x16\x8b\xcd\xfe\xa6"\x0f\xe2\x03\x10\x0c\x06\x01\
\xa8\xad\xad]\x10GFF,@\x88\x9d;\x9f\xdf\x15\xaf\x8e\x9d\xf9_v\x16\xc1\xad\
\x9b\xe9\xcd\xff\x00{*\xa3Z\xb4\xa4@\xad\x00\x00\x00\x00IEND\xaeB`\x82' 

def getSaveBitmap():
    return BitmapFromImage(getSaveImage())

def getSaveImage():
    stream = cStringIO.StringIO(getSaveData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTestData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x04vIDAT8\x8d}\x95]l\x15E\x14\xc7\x7f3\xb3{\xef\xed\xfd\xdc\xda\xdb"\x94\ni\
\xa3\xd0R\x05\x8c\xe1I\tQ\x91\x98\x10\xe3\x03\x89\xc6g\x1e|\xf0EcBbbL0\x86\
\x18\x12\x8c\xbe\xf8\xf1\x801\xfa\x80\xe5#\xc6\x90 \x82@B\x94J\x05\x894"\xa2\
\xa1-\xa5r\xa1\xd8\xdb\xde\xaf\xde\xdd\x9d\x19\x1f\xb6\xf7\xd2V`\x92\x93\xd9\
\xcc\x9c\xfd\x9d\xff9gfWp\x9fa\xad\x15]]]\xad_\xed\x9d8\xe18\xc2s\x14\x84\
\xdab4\x1fn\xdcl>\xb8\xdf\xbb\xe2\x1e\xeb\xde\xc0\x97\xe2J\xd7C*\xef81\x96w\
\xba8J\xe28\x16k5#c>\x93\x93!\xa7\x7f4_\xbf\xbb\xcb\xbe\n\x14\x17\x03\x9c\
\xbb@\xb7\x0b!^~|\xbd\xcc[\x91F\x8a,~\xd0\x02Va\x81 \xac\xf1@k\x95\xf6\xb6\
\x12c\xd7\xec\x16!f\x0fXk\xdf\x04.\xcc\x87\xa8E\xd0\x17\x85\x10\x1fwww{}\xbd\
6\xd3\xde\x9eD\xa96\x94\x93B\xaa\x04\xca\x89cL\x1cc\xa0^\x0f8s6\x9d\xb86\xbe\
$Y*\x956\x1ac&\x81?\xee\x06^\xe7\xba\xee\xfb===-\xb1Xl\xe9\xd4T\x82\xa7\x9e\
\xf4Q*\x89\x92\x12\xa9\x04JY\xb41\xe8\xd0\'\x0c\xaa\xec\xdc\xb5\x0c)e:\x97\
\xcb\xc9\x99\x99\x99\xc7\x8c1\xbf\x007\xe6\x83=\xe0\xfc\xca\x95+S\xae\xeb.\
\x15B0y\xdb\xc5Q\x96\xd5\x8fT\x90R#\xe5,R\xd6\x08\xc22\x81_f\xe0`\x92\xe1\
\xdf\xe3\x18c\x90RfR\xa9\x94*\x16\x8b\xeb\x81o\x81\xd9\x06\xf8B6\x9b\r<\xcf\
\xeb\x12"\xea\xa7\xb5\x96K\x97\x13\xf4\xae\x9a\xa2=?\x8d\x94\x15\x94,\x13\
\xfae\x82\xa0\xca;\xef-\xc7\x18\xd3\xf4u\x1c\'\r\xd4\xaa\xd5\xeaR\xe0\x98\
\x04\x10B\xa4;::Z\xad\xb5\xcc\xb70\x0c\xd9\xb7?\x85\x0e+\x18]\x02[\xc6\x98\
\x1a\xfb\x0e\xe40\xc6\xb0\xd8\xdf\xf3\xbcN!\xc4\x0b\x8dS\xb15\x93\xc9\xa4\
\xa5\x949\x1b\x85_\xd0\xcdK\x97S\x9c\xf99E\xa9\x12#\x91\x10<\xb1\xae\xc8\xc0\
\xa1\x8e\xffA\x01\xa4\x14\x9eR\xaa\x1a\x86\xe1V\x07\xd8\xd6\xd2\xd2r\xdbZ\
\x9b\x13\xc0|\xac\xb5\x16!\x04\xaf\xbd\x11\xd2\xd3\xb3\x02\xc7q\x98\x98\x90$\
\x12%\x92\xc9d\x13h\xe7\x89ikk\x9b-\x14\n\xdb$\x80R*\xdephX#\xd5\x9b7o\x92\
\xcf\xe7\x9b\xf5\xcc\xe7\xf3T*\x95\xe6\xfe\xe2\x92(\xa5\xe2\xd9l\x16\xf1\xc9\
G\x8ctv\xb2\xc2\x0f"\xb9bN\xb6%z>z<\xc6\x0f\xa7\x1eZP\x9eg6\x8d\xb1\xe5Y?\
\xca\xce\x02\x02\xc4\xdc\xec\xbap\xfc$_Hc\xa2\xb2\x86\x01\x84!\xf8>\xd4\x03\
\xa8\xd7\xa1Z\x83\xb5\x8fj\x92-\xb3\xf8\xbeO\xb9\\&\x16\xab\xb2fuH\xa9\x0c\
\xb5Z\xe4\xe7\xfb\xe0\x07\x10\x04\x11\xcb\x18P}}\xfc\x15sy\xc5u\xa2\x05m\xa2\
\x00:l8Zz\xba\xcb\x0c\x9e\xf5\x99\x99\xf1y\xfe\xb9*K:\x02\xac\x05k\xee\x80\
\xac\x05c\xe1\xf6\x14\x94J\xbc-w\xef\xe1p\xa8!\xd4\x110\x0c"\xab\xfbsV\x87s\
\xe7S\x80G&\x93\xe1\xc2o)\xea\xf5h\xbd\xeeGj\xc39\xb5\rA\xbb\xf7pX\x02\xccLS\
\x102\xda\x08\xe6\x946\xe7\x00\x06\x87\xb2\xcd\xfa\xfes#\xce\xe8X\xbc\xb9\
\xd7\xf0\rC\x90\x02fg\x99\x01\x90\x00\xb7\nl\xaf\xd5\xa2>\xe80R\xaf\xe7\x14\
\xfc4\x98Yp\xa4\xac\xb5|s8\x1fe\x17\xde\xc9\xd4\xda\xa8\'J\xb1\xb3\xf9\xad83\
\xc4\x9fkzy)\x95\xa2]\x88\xb9\x94\x0c\x8c\x8e\xc59v\xb2u\xc19m^y`\xf92\x1f!@\
\xc9(\xc0w\xc7\x9c\xd7O\x9d\xee\xff\xacP(\x04\x12`\xc3\x86\r\xd9#\xc7\xd7n\
\xfe{\x84\x89\x7f\x8b\xe08\xa05\x0c\x0ee\xb8\xd7\x18:\x97E\x9b(\x80\x1f\xc0\
\xc8(7\xc6\xc6\xd7\xec\x17B\xb8\xcdR\xd4\xebui\x8c\x11\'N\xad\xdbt\xf5\xaa\
\xfa|t\x0c\\\x07\xc6\xaf\xc7Jv\xd1\x15\x9fw+K\x03\x07\x93\xd7\xa7\xa7\xa1pK\
\x1e:\xf2}\xefFc\x8c0\xc6\x08\x98\xf7k\xea\xeb\xeb{\xd0q\x9c\x16\xc0]\xf5\
\xf0\x95\xa7\xdb\xbc\xda\x8eO\xf7\n\x94RI\xa5T"\x95J\xd5\xac\xb5T*\x95\xa4\
\xd6\xba\xa6\xb5\x8e\t!~\xed\xec\xec\xdc\x91\xc9d\x8a\xb1X,\xd0Z\xd7\x86\x87\
\x87\x0b\x0b\xc0\x00\xfd\xfd\xfdK\xac\xb51)\xa5\x1b\x04\x81\xe38\x8e,\x16\
\x8b\xd9\xe9\xe9\xe9\xb7\xca\xe52\x00\xe9t\x1a\xcf\xf3\x8e\xe6r\xb9\x93Zk\
\xed\xbanh\xad\r.^\xbc8>\x9f\xf5\x1f\xa31\x81\xcc\x9a\xc8\x87"\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getTestBitmap():
    return BitmapFromImage(getTestImage())

def getTestImage():
    stream = cStringIO.StringIO(getTestData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_ControlsData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03\xd3IDATh\x81\xed\x98OL#e\x18\xc6\x9f\xceN\xa53\xb4)s!M\xba\x1a\xf1PG\
\xc0+\x065\xb2\x06h"E\xf4D(K\xd2\x83z\xe7\xb4\x1c\xd4\x03\x81\x03\xab\x92\
\xaa\xebuMv5\x91e\xd3\x8d+\x15\xcd\xae\x81d9\x18\xda\x90\xd5e\xc3\xc1\xc5\
\x1e\xd6\xe5\xc0\xa1\xa4\xb6\xc3\xectv:\xaf\x07\xb0\xa13];\x14\xe9\xb4I\x7f\
\xc9\xd7\xe6\xfb2y\xe7y\xfa\xbd\xef\xf7\xa7\x0e\x07s\x06\x8d\x0cc\xb7\x80\
\x93\xd24`7M\x03v\xd34`7\ro\x805\x0e|\xb7p\x8dx\x9e\xb7CKEX\x96\x05\xcfsx\
\xf3\xdc9Gq\xec\xe8\x03\xcb\xcb?Qo\xef+p\xb2NP\xed\xf5Y"\xfe\xe3rI\xbf\xc4\
\xc0cE\x01\xcb:\xf1D\xd3j*\xea8\x90\xe1\x975\xa5\x10\x88\xa0\x93^#9\xc7\x87\
\x0c\x0eL\x06\x08\x04\xd4\xaf~\x00\x95\x0c\x10\xa0\x9f\xa0\x02~\xb8y\x13\xbf\
\xdd\xbd\x0b\xbe\xb5\x15R.\x8b\x0f?\xfa\x18S\x17.\xe0\xd3\xcf\xe6\xf1\xcd\
\xd5+(\xe8\x05\xbc\xf7\xfe\x07U\xc77*+c\x80\xcc\x89f\x11UUq\xfb\xf6-\\\xba\
\xf4\x15\x00\xe0\xce\xda\x1d\\\xbf\xbe\x08\x80\xf0\xc9\xc59tuwcdd\xa4\xea\
\xf8\x07\x02K\xbbe\xf6\x01\x82N\xd55i_\x82\xd0&\x14\xfbg\xcf>\x8b\xdd\xdd]\
\x10\x80\x07\x0f\xfe\x80\xf8\x92Xu\xec\x7f\x9b\xb1\x06L\x06\x88\x0e?\xaahm\
\xde6\xa4\xf7\xd2H\xa5\xfeD^Q\xf0\xf5\xe5\xcb\x18\x1c\x0c\x02\x00\xa2_|\x89\
\xcf\xa3Q\xdc\xbf\xbfYu\xfcCq%z\xcb\xa6\x90~\x82)\x9e\x9b\xbb\x88\xd8\x8d\
\x18\xfe\xced\x10\x0e\x87\xf1\xa2(b0\x18\x04\xcfq\x98\x9f\x8fbq\xf1\x1aDQ\
\x04S\xe5M\xb0r\r\x94}\xcc:\x1c\xcfabb\xa2$b0x0\x0b\xcegX\x9c\x9f8\xff\x14)\
\x16\xb1\xb4\x0f\xd4\xf12J\x95RH\'\x1dz\x1d;\xf8\xcf\x8d\x8cs\xb9 \xcb\nd\
\xf9qME\x1d\x0b\x83\x01\x87\xf1o\x95+W\xbf\xa5\'\x9a\x06\xd2\xeb\xef8\xc7:Y\
\xbc\xf0\xfcs\xe8\xeb\xeb+\x9eFM\x06\x1a\x8d\x86\xbf\xd04\xbc\x01\xd3*\x94H$\
\xe9\xafG;vh\xa9\x88\xcb\xd5\x82\xd0\xd0[\x8e\xa3c%5\xf0\xfb\xbd{\x94\xcb\
\xe6\xf0rwg\xcd\xc5YAQ\xf2\xf8u=\x89w\xdfy\xbb\xfc\x95\xf2\xe1\xc3Gx\xe3\xf5\
^x<\x9e\xda\xab\xb3\x80\xc7\xe3\x01\xc7\xb9J\xc6\x0c5P\x7fKg%,\x15q.\x97\xc3\
\xca\xca\x8a\xa5\x80KKK\xa6\xdd\xf241\x9f\x85\x0eY__\xc7\xea\xea*\xfa\xfb\
\xfb\xe1\xf7\xfb\xb1\xb0\xb0\x80\x8d\x8d\r\x84B!tvv"\x95J!\x16\x8b\xa1\xbd\
\xbd\x1d\x91H\x04\xc9d\x12kkkH$\x12\x08\x85B\xd8\xda\xdaB<\x1e\xc7\xf0\xf00\
\xba\xba\xbaN\xcf\x81\x839Sl\xf1\xe5\x9f)\x9b\xcd\x12\x11Q:\x9d&UUitt\x94vvv\
hhh\x88dY\xa6p8L\xaa\xaa\xd2\xd8\xd8\x18\xed\xef\xefS:\x9d\xa6|>O\xe3\xe3\
\xe3$\xcb2\xf5\xf4\xf4\x90\xa2(\x14\x89D\x8a\xdf\xff\'\xb7~Y\xa1\xa3\x9a\xcb\
\xce\x80\xaa\xaa\x98\x9a\x9aBGG\x07\xb6\xb7\xb7\xa1\xeb:DQ\x04\xc7q\xe08\x0e\
\x92$\xc1\xe7\xf3\x81\xe7y\xf0<\x8f\xbd\xbd=\xf8|>p\x1c\x87@ \x00I\x92\x90J\
\xa5\x10\x8dF\x11\x08\x04@Dp8\x1c\xe5^ub\xca\x1a(\x14\n\xc8d2`\x18\x06\x0csP\
&\xc9d\x12333\xf0\xfb\xfd\x10\x04\x01\x82 `zz\x1a^\xaf\x17\x93\x93\x93\xd04\
\r\xb3\xb3\xb3\xd8\xdc\xdc\x84 \x08\x18\x18\x18\x80\xa6ip\xbb\xdd\xa7&\x1e\
\xc0\xd3S\xa8^1\xa6P\xc3\x1f%J\x0c\xb4\xb4\xb4 \x9fW\xed\xd2b\t\xe3e\xcbt\
\x9c\x8e\xdd\xf8\x9e\xdc\xee\xd6Zj\xb2L\xa1P\x80\xd7\xeb\xc5k\xaf\xf66\xef\
\x03uC\xd3\x80\xdd4\r\xd8M\xd3\x80\xdd\xfc\x03B\xb8\x043\xa9\x17\x98:\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getToolPanel_ControlsBitmap():
    return BitmapFromImage(getToolPanel_ControlsImage())

def getToolPanel_ControlsImage():
    stream = cStringIO.StringIO(getToolPanel_ControlsData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_DefaultData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x0c\xb1IDATh\x81\xed\x99{\x8c\\\xd5}\xc7?\xe7\xdc\xc7\xdc\xd9\xd9\xdd\xd9Y\
\xef\xcb6\xd8\x18\xf346\xe0`\'\x84\xc6\x90\xba%Dj\xabTM+!\xb5\xff\x90\xf4\
\x11U\xadTEJ\x1b\xd16\x95\xfaG\xa8\x04%iJQ\x1a\xa9\x89ZB\x13\xa0\xd4\x10\xf0\
b\x1bc\xfc\x02\xdb\x01\x83\r\xb6\xb1\xf1\xee\xda\xfb~\xcc\xec\xec\xcc\xec\
\xbc\xee\xe3\x9c\xd3?\xee\x8c\xbdl\x97\x04\x9b\xe4\xaf\xf8\'\x1d\xdd\x19\xcd\
\x9d{\xbf\x9f{~\xe7\xf78\x17\xae\xd8\x15\xbbbW\xec\x8a\xfd*\x9b\xf8%]O|\x84k\
\x9b\xc6`\xc1\xf1\xb2o\xf8q\xad)X.\x1a\x1fv}\x03\xe8Ec!\xd0%\xdd\xf8\xe3\xd8\
B\xe1\t\xc0\x06Z\x80e\x8d\xcf\xe9\x05\xf7\x98\x07\n\x80\x02" l\x8c\xa0\xf1=\
\xe22@.\x17`\xa1p\xa7!\xfa\xe6\xa9\x81=\x07\x84\x00\xe9\xba\x04~H\xe0\xd78\
\xf4?OP\xafG\xf4t\xba(\x05\xe3\xd9y\xfe\xfc\x9f\x7f\xf2M`\x17\x90m\x80U\x1b \
\xe1\xa5\x82\\*\xc0R\xc2\x7fcf\xe8\xd5\xa7\xa4%\xf1Rm \\\x86\x87\xceR\xccMqp\
\xcf\xcb\xdc\xfb\x85\xdf\'\xd5\xd2\x81]\x1e!;|\n\x19\xd5\x99\xcc\xcf3\x9b\
\xab\xf3\xc0C\xdb\x1e\x05^\x01F\x80"P\x03\xfcK\x01\xf9\xa8\x00K\n\x9f\x1e|\
\xe5)\xdb\xf3H\xb8)\x84\xb4\x99\x1c=Gan\x8e\x83\xdb~\x8c\xb04}]izo\xbd\x9bLW\
7\x99\xcc2\x1c\'\x81\xf6\xe7\x18;\xf22B\xf9\x94\xfc\x88\x81s3|\xe5\x91\x17\
\x1e\x03v4@\n\x97\x02\xf2\xf3\x00\x16\x0b\xf7\x80\xf5\xd3C{\xf6[\xb6\x8d\x97\
J#\x80\x89\xb1Qf\xb3\xd3l\x7f\xf2\xbf\x08\x02\x05@\xa6#\xc9\xf2\x8e6Vl\xba\
\x1bi\x81\xe3\xd8$\x93\x9d\xa4\xd3ilGR\x1d?\xc7\xfc\xc4\x00\tYeh\xb2\xc0|\
\xd1\xe7\x81\x87\xb6=\x06\xbc\x00L~T\x90\x9f\x05\xd0\x14n\x03I\xe0\xd3\xd3\
\xc3{\xfbm+\x81\xeb\xa5\xd0\xc601r\x9e\xb9\xe9)^}\xf6)\x8a~x\xe1\x8f\xae%imu\
\xc9\xb4\xa5\xb8\xf6S\x9fEZ\x8d\x1f\x0c\x84AHk\xba\x8b\x96\x96V2\x99\x0e\xa2\
\xec0\xb3C\xc7\xb1\x85Ov\xd6gb\xb6\xc8\x97\x1fz\xee\xef\x81\x83@\x8e\xd8\xb5\
\xaa\r\x90\x808\x084A>\x14@\x00\x16qd\xf9\xb5\x99\xe1};m\xc7\xc5qZ\xd0\xc60\
\x9b\x9dad\xf04\xafn{\x96z\xa0p\xecXa\x10F\x18!\x10B\xd0\x9et\xe9\xeeL\xb1z\
\xd3\x16,\xdbA\x08\x816`T\x84\xd6\x8a(\x08H\xa5\xdaI\xb5w\x90\xc9tb\xcd\xcf\
\x90=w\x12\x11\xce\x93\xaf\x04\x0c\x9c\xcf\xf1\x97\xdf~\xf1\xef\x80}\xc0\\cT\
\x81zcF4`>\x0c\xc0\x01\xee\xca\x9d\xdf\xbb\x17@&\x12H\xab\x95\xec\xf4\x18\
\xa3\x83g8\xf8\xdc\xf3\x04FcY\x02\xa1\x05\xa1Q\x18\x03\xc6\x180 \xa4\xa0%i\
\x93N&Ys\xe7\x16l\xcbA\xe5\xa6Qg\xdf\xa3:5B\xc9\xf5h_\xb7\x01\xaf\xbb\x17\
\x1d\xd6ik\xeb \xd3\xdbG\xef\x8a\xb5\xe8\xfc(\x93\xa7\xdf\xc4\xe8\x1a\x83\
\x93yrs>\x7f\xf5\xe8\xf6\xbf!^#y\xa0\xd4\x80\x88\x00m-!^\x02_\x1a=\xbd\xe3\
\xd9z\xcd\xc7\x0f}f\xa6&\xc9f\xa79\xbe\xfd\xbf\x19\x1f\x18\x00\t\x96#0Z %\
\xb8\t\x0b\xcb\x92HK\x90+\xf52V\xfd\x1c\xb9B\x07\xed\xde\x08\xc9L7\xea\xec):\
\xa7r\xf4xi\x12^\x12\xbf0C\xf6\xfdc\xa8Z\r\xaf\xb3\x13\x7f~\x9a\xe2\xc40\xe5\
B\x1e7\x95\xa6g\xddfN\xbfq\x98JM\x11F\x8aO\xdd\xbc\xf2\xde}o\x9f\xaf\x03\xa7\
\xb8\x18n5\r\xff\xfe\xff\x8f\xdfq\x8e^}\xd3\xe7?\xd7\xa0\xbcif`\xf7\xe3\xad\
\x99.\x92n\x82\xa1c\x87)e\xcfS)\x87\x04~D]+\xa4\x84\xa1\xd14G\x07\xaf"\xd3\
\x9d&\xe9\x950\xb6\xc5\xbeS\xbd\xe0\x8cp]}\x92\xe4\xaa\x9b\xe8N\xf7"\xf2cx\
\xee4\x88\x1c\xe5s\xa7q\xdb[\xb1S)"\x1d\xa1\x8bU:V\xb7Q\xf6C\x06\xc7\xe7x\
\xf0{{0\xc6\x1c\x13B<\xd9\xd0\xea5\xdc\xba\xdat\xff\xa5f@h\xadg\x88\x93L\xdf\
\xf4\xd0\xceg\x12I\x17\x81\xa0\xa7\xaf\x975\xebn\xa3\xac\x12Du\x1f\xcf\r\x10\
F\xf0\xc4\x8e\x1b8?\xd3\x8e\xe5\x18\x94\xae\x12\xf8%\x8a\xa5i\x02\x15\xd0U9\
\x8e\x9bL\xd2\x9a^\x86\x94P\xab\xcd3W\x9c\xa2\\+\x01\xa0U\x88w\xd5Fn\xb8\xeb\
\xf3,_s=\xe1\xdc\x04\xe3\xa7\x8e\xa0\x83\x80;n\xec\xe5\xd0\xa9\xa9\xe7\x85\
\x10e!\xc4\xa8\xd6:\x00\xca\xc4\x0b\xfaC]H\x10\xc7\xf9\xf5\xd3C;\xf7{^\n\xdb\
N \xd0h\x15\xa2\xb5a\xf55\xab\xb8\xee\xb6;\xb0\xda\x96q\xead\x91\xc1aE\xa9b\
\xb0,\x8d\xd1u\xea\xf5"\x95Z\x9ej\xad@W8@\x1d\x07\x83!\n\x8b\xcc\x97\xb3L\
\x15\xa7\xb0\x93)\xba>q/\xeb\xbf\xf8\'\\u\xc3\r\x88\xc2\x14\x85\xb1w\x88\x8a\
\x93\xd8\xa6N\x9bg\x93\xf2\x12|\xe2\xfa\xbeM{\x8f\x8d\x9ci\xf8\x7f\xc5\x18\
\xe3\x13\x87\xd7\x000\x8b\x01\xbc\xc6\xacl\xc8\r\xef9\xe4&\x1cl;\x81\xb4\xc0\
r\xbd\xd8\xed\xb4BiM\x14T\xe9\xee\xbb\x9a\xdb?y\x0b\xd7\xaf)\xb1\xa2m\x96\
\xec\xac\xa1\xe2[\x18\x02\xc2p\x9ez\xbdLK\xa2N\xadR\xa2V/R\xaf\xcdalM\xf7\
\xc6{\xb8\xe5\x8b\x7f\xca\xaau\xeb\x89\xe6\xc6(\x0c\x1f\'\xa8\xe5\xb0T\x80\
\xd1>D\x11hhK{x\xd2a\xf3\xcd}\x9bw\x1f=?&\x84\x98\x10BT\xb4\xd6\xcd\xdc\xa0\
\x16\x03\xc8\xfb\xef\xbf\xff\xd7\x0f\xec\xfa\xee^\x8c\xc6\x92\x0e\x96\x10\
\x08)\x10\xd2FH\x1b\xd0\x8d\x88\xa3\t\xfc\nZ\x05\xacY{\x13\xb7\xdfy+\xab\xaf\
\xae\xb1<\x99%_\xb2)V#0\x01-I\x83\xa8\xcd\xb2,\xd3\xce\x86-[\xb9\xfd\x0f\xfe\
\x98kn\xd9H47Fy\xec$Q-\x8fC\x84Q\n\xa3#0\x1a\x94&\n\xc0NH\xda3\xedt\xb8\x0e\
\x1b\xd6tm\xdeq\xe4\xac\x00\xde3\xc6T\x1b\x00\xd1\xc20*\x80;N\xfc\xf4\x857\
\xaeY\xbd\x02\xe98\xe8\xa8\x16SY -\xbb\xe1\xb3\x11Z\x81\x8aBT\x14\xa1\x8dF\
\x85\x1a\xdbvI$S\x84*\xe2\x8d\x03{y\xef\xed!\xf6\x1c-\xb223\xcb\xd6\xcf\xdc\
\xce\xa6{\xef\xc3\xe02s\xee\x04:\x9a\xc3\x8e\xeaDa\x844\n\xa1#\xa2H\x81\xd1h\
\xe5C\xa0\xd0\x16X\xb6\x8d\xb4\x93h\xdbcvt\x84\xc1\xf1<_\xfd\xce\xce\xdd\xc6\
\x98\xaf\x03S@q1@\x1ax\xe0\x99\x7f\xf9\xca\xa3\xd7^\xbb\x96[>s\x1f\x96\x94D*\
@\x87\xfe\x85\x13\x8d\x90DQ\r\x1d\x11\x03\xa8\xf0\xc2r\x12\x96E\xb2\xb5\x83\
\xb9|\x91w^\xdf\xcd\xe6\xad\xbf\xc7\xb2\xcev\x86O\xbdN\xb5R$\n*\x84\x91\x82(\
\x04\xdf\x07\x15_W)\x1d?}@\x18\x85\x166\x96\x0b\xe5\x99"\xfb\x8e\x0fS\x0f\
\x14\x0f\xff\xf0\xc0\x8f\x84\x10/i\xadO7\x00\n\x8b\x01dc\x01w\x00[\x9e\xff\
\xc1\x83O^\xb7\xa2\x87\xb5\x9f\xdc\x8a\x94\x86Zu\x1ec\xa2x&"0\x18\x94\x8e0Z\
\x83\xb6\x88T\x88\xed$\xd1Z3\xfa\xd6+\xbcr\xf0]\xbe\xf4\xb5\x7f\xc0\xb3\x0c\
\xb9\xf3G\x89\xfc\x00\x1d\xd5Q*\xa0^\x0fQA\x80\xd6\nK\xc4\x10\x91\xb2\xd1a\
\x88\x12\x92\xe2\xc4\x0c\x87N\x8e\x82\x11<\xfc\xe3\xd7vh\xad\x0f\x02\xb3Z\
\xeba\xe2Zi\x1a(-\xce\xc4\xcd\xa2-I\xdc\x94\xf4\x01wo\xfb\xd7\xbf\xf8\xe6\
\xcd\x9b6\xb3r\xed\x06\xb41\xd4\xaa\x05\x84\x89>\x10\xc4"\xe5#\xad$*\xf4\xc9\
\x1e\xdf\xc3+o\x0c\xb3\xe5\xb7\xbf\xc0\xd8\xd1\xfd\xfc\xe6\x1f\xfd\x19\x8e%\
\x19?}\x08\xe5W\xd0\x12\x82\xbaO}\xbe\x8c\x0ejhm0Z\x11*\xc3\xe4\xd8\x14\xaf\
\xbd5L\xe4\x08\xfe\xe3\xb9\xb7\xf6\x01\x87\x8d1\x05`Zk\x9dm\x08\xcf\xd2(\xbf\
\x97\n\xa3\xcdj/$\x0eW\x85\xa7^\xfa\xe9\xf4]\xab\x9d-\xa5\x99I\x92-6N2\x8d\
\xb0\\|?\xce\xe8\x06\x10R\xe2\xd7\xaaL\x1d}\x81\xd7\xdf\x1c\xe0\xce;o\xa5g\
\xf9j\x86\xde=\xc4\xcc\xe0\x007n\xfa4m\x9d=\x14\xa6\xce\x83\x8a\x10a\x88\x8a\
|r\xf9\x12\xd5j\xc0\xe4D\x8e#\xc7\x06\x98+\xd5\xa8\xd4C\xbe\xff\xe2q\x84\x10\
Ok\xadg\xb4\xd6\x93\xc6\x98\xf1\x86\xdb\xe4\x88\x9b\xa0:\x10\xc9%\xc4\xeb\
\x05\xe2\x8b\xc0\x00\xe0_\xbb~\x1d\x9e\xacqx\xc76N\xee\xdf\xc5\xf4\xe9c\xb8\
\xb6\x8bt\x92D\xa1\xa2^\xa92\xfe\xdas\xec:x\x96\xd5+2H\x19\xe2y\x16\x8ee\x93\
\x9f\x9d\xa4\xff\xdf\x1fAH\x8fU\xeb\xb7@\x14a\xc9\x08\xbf\x16\x92\x9f\x99\
\xe3\xe0[g8=<Mo{\x1b\xcb{\xdaY\xd5\x97F\x08\xb1\x07PZ\xeb"0\xd1p\x9b\x19\xe2\
2\xbb\xd9\xc1\xa9\xc5\x00KA\x94\x81\x92\x85F\x08\xc1\xb5kW\xe2D9&\xde\x7f\
\x93\x93\x87w\x93\x1fx\x17\xbf\x1erf\xf76^?1\xc9\xc6\x1bW\xd0\xd5\xdd\x8ae46\
\x02\xdb\x12\x08\x01\x85r\x91\xfe\xef}\x1b\xb7\xa5\x83U\x1b\xb72\x9f+\xb2\
\xeb\xc0\xdb\x9c\x18\x9c\xa2\xab\xb5\x85em-(a0\x91a2[\x06P\xc6\x98\xba\x94\
\xb2L\x9c\xc4\xe6\x1aZ>P\x8d.\x05\xb0\x10B5N\x8et\xa4p{V\x83\xdb\x81\xdd\x92\
\xa6\xbd\xa3\x13\'\x98\xe3\xd8k\x079q\xe0\'\xec\x7f{\x88\xd5\xcb;hi\xb5\x01I\
\x84$\xb2\x1d,\xdb\xc6\xb1$\x18Mn~\x9a\x1f>\xfc\x8f\x14+\x11/\x1c<K\xdaK\x90\
i\xf3\x08\xa2\x08m\xe2\xb8/l\xc1\x8a\x9e6\x8c1Jk\xed\x0b!\x9a\xbd@\xb3\x1fX\
\xd8\xd8,]\xcc-\x05#\x8c\xc1vS\x08\xcb\xc6jM\xa3\xfc*\xcc\x17X\xb5\n"\x15\
\xb2\xf5\xae\xeb\xf1ZZ\xd1a\x15\x00\xe9$\xd0\x91\xc6\x12\xe0:6\xa1\x06\x11\
\x1a\xaaa\x91\xa7\x1f\x7f\x88V[\x11\xc5\xcd\x1b\x96\x8cc\x89\x83\xc4\x95\x0e\
\x133Y\x8c1!PRJ5\x9f\xf8\x92\x1d\xd9\xcf\x03h\x9el\xaa\xf9\x19\x92\x1d}X\xa9\
\x0c\x81_\xc5J\x00a\x88\x11\x16\t\x1d`\xa4B\x91\xc4\xb6\xe2I\x15\xd2\xc6H\
\x9b\x84\xb4\t\x8d\x8f\x94\x90p%\xf8\x16\xdaht"n|T \x1aB$]\xdd\xdd,\xeb\xeb%\
_V(\xa5BcL\x91x\xc1\xfa\x0b\x9f\xfaB[*\n-6\x01\x8c\xfcg\xff\xdb\xd5?\xfc\xad\
\x8d\xf7P\xaf\xe2z),\xaf\x1d\xa4\x83\xb4l\x84%\x91v\x12iY\x08a\xa1\x85@\xd8\
\t\xda\xbb\xaf\xa60q\x06\xa5B\x82P\x83\x00\xcb\x92\x08\x04\x18\xb0\x84\xc4\
\xf5,:;\xbbX\xb9f\x15\xa3\xe3y\x9e9\x9c\xe5\xbb?\xea\x7fT)\xf5\x06q\xb8\xccq\
\xb1\x89Q\x8b!>\xca\xae\x84 \x9e\xa9\x0e #\xa5xd\xd7\xf7\xbf\xf6;m^\x82T\xcf\
r\xf0Z\xf1\xab\x05t\x18B\x10\x97\x1eZ\x82\x894\xab6\xdc\xc3\x99\xbd\xffK~n\
\x1a\x13h\x8c\x16\x04Z\xa3U\x9cq\xdd\x964\xed\x9d\x9d\xbc?0\xc2\xde\xb3!/\
\xbd\xf4\xd2\xe3A\x10\x8ck\xadg\x89#\xce\x14q\xdc\xcf\x13G\x9e\xf0r\x01\x9a\
\t.\x05t\xd9\xb0LK\xf9\x8d#\xcf\xfc\xed}\x96\xe5\xe1\xb6g\x10\x89\x14\xf5Z\
\x11\x8c\xc2\x18C\x14iV\xdd\xb0\x99\xb3\xfb\xb61\x97\x9bF\t\x00\x8d\xf6\x01\
\'I\xba\xa7\x97\xd3g\xce\xf3\xea\xfb\x01\xdb\xb7o\xff7\xad\xf5\x94\xd6\xba\
\x00\x14\x1a\xc7,0\xcb\xc5^8`\t7\xba\x94}!\x8b\x8b[+)\xa0\xd3\x86\x0e-\xc5\
\xbe#O\x7f\x03\xcbvq\xdb\xd2\x88\x964\x95J\x99\xd0\x0f\xb8\xe6\xfa\xdb8\xb3\
\x7f\x1b\xa5\xd9\x19\xc2@aZ\xdaH/\xebehp\x98\x1d\xef\x94\xd9\xb9s\xe7cA\x10L\
\x00\xa5\x86\xe8*\xb1\xcb\x14\x1a\xa3B\x1c\xcaC\x96p\x9fK\x01h\x9e\xdb\xdcfq\
\x89[\xbb$\xd0aYV\x97\xd6z\xcf\xebO~\x1da,L\xa6\x07\xdbke\xc5\xca5\x9c\xd9\
\xbf\x9dR\xb9\x80L\xa6\x19\x1e\x1cg\xf7\xfb5\xfa\xfb\xfb\xbf\x13\x86\xe1$\
\xb1o\x17\x1b\xc7\xb9\xc6\xe7\xf9\x86\xf0\x85\xd1gI\xf1\x97\n\xd0<\x7f!\xc8\
\x85\x19q\x1c\xa7Ck\xdd\x85\xd1/?\xf3\xad/\xe3ym\xac\xfb\xec\xef2q\xf20\'\
\x8f\x9f\xe0\xc5c%\xfa\xfb\xfb\xff)\x0c\xc3<qB*4\x847\x8fM\xe1K\xc5\xfb\x8f\
\xbd\xb5\xf8\xb3@\x9a\xc5\x9f\x9bH$Z\xb4\xd6mZ\xeb^\xa5\xd4Ww\xfe\xe0\xc1\
\xfb\xf6\x1f>\xc1\xb7\x9e\xd8\xfd\xd7\xd5j\xb5\xe9\xc7\xa5E\xc2\xcb\xc4n\xd2\
t\x95\x88\x8b\x89\xf4\x17\xbe\xb9\xbb\xd4\xff\x9b\xef\x02\x12\r\x18\xb7\x01\
\xd4N\xbcVR\xc4\xb3\xa4\x89\xdd\xa2\xd2\x10^\xe1\xe2\x8e\xdb%\xefJ\xff\xa2\
\x00\x9a\xb6\xf0\x85F\xd3\xb5\x12\r\xe1^\xe3;\xc43P\xe7bS~\xd9\xc2\x9b\xf6\
\xcbx\xc5\xb4p\x8d4G3a^\xa8\xad\xf8\xe0\x1e\xe7e\xbfb\xbabW\xecW\xdd\xfe\x0f\
\'\x0c\x97\x14\x15\xaa\xbd\xe8\x00\x00\x00\x00IEND\xaeB`\x82' 

def getToolPanel_DefaultBitmap():
    return BitmapFromImage(getToolPanel_DefaultImage())

def getToolPanel_DefaultImage():
    stream = cStringIO.StringIO(getToolPanel_DefaultData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_GizmosData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\t\xb6IDATh\x81\xed\xd9K\xa8]\xd7y\xc0\xf1\xffZk\xbf\xce\xd9\xe7q\x9f\xd6\
\xbd\x92\xad\x87\x1f\xb5\x94\xa8\x10\x88!-i=0tPB[\n\xc5P\xe8,\x03\x93 \x1c\
\x88\x071\xc5P<H=(\t\x14j\x1a\x1b\x8cq=(\x18Z\x8c\t-\x866\xc5m\xa1)\x95\xa9\
\x1d\x1cT\xacZRb\xc9\xb2\xee\xf3\xdc\xf3\xda\x8f\xb5\xd6\xf7up1d\xaa{\xc5q\
\x07\xfe`\xcf\xceb\x7f?\xbe\xbd\xd7\xb7\xbe\xb3\xe1\x8b\xf8"\x8e\x15\xe68\
\x8b_}\xf5\xd5\xe2\xf2\xe5\xcb\x17\xf7\xa6\xdb\x8f.m\xf6\xcf\xab\x91n~\x9f[-\
\x07\xe5\tglQ\xcf\x03IfP/\xcd\xd6\xad\xd1\r?mGq\xa2W\xcf\x9d<\xfd\x93\xef\
\x7f\xff\x07\xd7?7\xc0\xf7\xfe\xec\xe9\xd3\xad\xd1\x17\x93\x93\xf1\x89\xe5\
\xd3ew\xb0ZRn\xe4L>m\x18\x9e\xecB\na\xaa\xd4\x07\r\xdd\xa5\x94j7\x12\x82\xe7\
\xe0\xf6\x8c\xbdkS@\xc5\xef\x9ag\xff\xea\xcf\x7f\xf4\x17\x9f\x0b\xe0\x8f\xbf\
\xf5G\xef|\xf9w\xce=~\xfd\x83\x1b\x94K=\xd4)\x9d2G\xa3\xc1\x18\x8bI\x15#B "Q\
\x08S\x03eK\x88\x81^\xaf\xc7\xb9\xaf\x9c\xe1\xc6\xbb\x9f\x04\xff\xdf\xe6\xcb\
?\xfc\xe1\x8b\x1f\x1e\x07\x90\xdc\xed\x82\xef>\xfb\xdd_\xdb\xf2\xbf|\x1c\x07\
k\x0f\xae\xe1\xa5\xa1s\xc2\x91\x96\x90\xe4\x96\xb0\x0b\xdd\xcd\x82\xa4p4uC\
\xa8\x032r\x94\x0f,\xb3}}\x87S\x9b\x9b\x8coMY9S&7\xael?\r\\:\x0e\xc0\xde\xed\
\x82\x0f\xde\xff\xe0K\x83\xb5>Y\x96\xd0\xef\x95\xd4\xdb\x9e~g\xc8d\xa7b\xbcS\
Q\x8d=\xe3\xed)\x07w&4\xf3\x96f\x1a\xa8}\xc3\xdeG\x07\x98:\xc3\x91`\xd5\xa2S\
K\xb9\xd1y\xf2\xf2\xe5\xcb\xe9q\x00w]\x81r\xd89\x1bC`\xb6S\x11\x1b\xc3d\xab\
\xe2\xfa{\x9f\xe0\xb0\xd84`\xa2\xe0\xc6`3\x87"\x84 \x14\x9d\x8c\xd9\xed\x86\
\xf5\xcd5F7\xa6\xe4\xdd\x84(J\xb1a\xd7_\xfe\x9b\x97\xbf\x06\xfc\xfbQ\x01w]\
\x01c\xc9\xb22%_\xcaH\x87\x06\x93\x08I\t\x94B\xb0\x91\x98x\xbc\x06B\xd2".\
\x92\x0e\xa0\xb5\r ,o\x94\xb8\\\xc9{)\x08\x0c\xd7\xfa\xc4\xac\xf9\xdd\xa3&\
\x0fG\xa8\xc0|6\xdf\x95\xb8\x84\x8aBT\xc0\x11\xbcbP\x14A\xa2!N\x84\xa2H\x89\
\xad\x10\x82"\xb5\xe24\'\x06ADi\x9a\x88DED)\xefK\x7f\xeb8\x80\xbb\xae\xc0lZ\
\xef4s\x8fz!\x84\x80M\x0c\xa1\x8ah\x00\xd4\x12B$\xb4\x8a\xaf\x02\xcd\xd4\x13\
\xe6B5j\xc9\xf3\x9c\xe9~E]y\xc4\x0bIj\xa9G\r\xc1\xfa\xc7\xdez\xeb\xad\xee\
\xc2\x00\x17\xce_\xd8\x9a\x8d\xe6\x84\xa0\xb4M\x80\xa8\xc46"^\x91V *\xd6\x19\
4X\xb4U\xa4\x8eXu,\x9f\x1c"\xde Q\x98O\xe6\x04\x1f\x98\x1d\xd4tW\x8a\xee\x8f\
\xdf\xfe\xfb\xf3\x0b\x03<\xfa\xe0\xa3\xef\xcdGM\xa8g\x9e,KH\x92\x14\x15@ 4\
\x01\x02\xb4\xf3@\x98\x07D\x04\xdfD:y\x8eEi\xe7\x81\xd4X\xb2,\xc5\xa5\x8e,M)\
\x079\xa3j\xfa\xf5\x85\x01\x9ey\xe6\x99\xca\xcf\xc3\x8d\xbcp\xb8\xc4\x11\xc5\
\x13cD\x82\x00\xa0\xc6`r\x83x\xc0@=m\xe9vKBT\x8c\x81(\n\x014(`\xb11\xa3\\-~}\
a\x00\x00iyw|\xa7\xc2\xcf"\xf5<\xa05\xc4\x00\x1a\xa1\xad<I\x02\xf5~\x8b\t\
\x96P\x0by\xdeE\x02H\x10L\xeb\x98\xec54#A\x03\xf8\xe8I\xba|i\xb1\x80\xa0\xef\
TuEZ\x16\x18\xa3\xf8\xb9\xe2\xeb\x08\xde\xa2-8M\xb0\xe2\x885$!\xa3:hiG\x11\r\
J]yl&\xe4}(\x973\x9ayC\xda5\x17\x17\n\xd8\xdc<\xf5/\xbb\xb7\xf6\x11\x15l\nIa\
0I$\xeb[L\xae\xd8\\\xf1\xea\x89\xa6&\xed\xa5\xa4\xa5\xc3\x14J\xb1\x94#>\xa2*\
\xa8\xe8\xe1V,\x06\x9b\xb9\xe1K/\xbdt\xa4\x9d\xe8H\x80\xd7^~\xed\x7f\xc6[\
\xb3\x9bV\x05\xef\x03!\x04\x8cB\xf0\x82u\x86\xe0#6S\xaaY`0\x18"A\x89QQ=\xbc\
\x10\x83*\x88\x08i\x96\xd1\xe9\xe7\xfc\xfc\xc3\xf7.,\x0c\x00\x10\xbd\xbe=?h\
\xd8\xbf9a\xba]\xb1\xff\x8b\x19\x93O+\x04\xa5m\x84\xa2Lh\x0f<Y\x96R\xcf\x1a\
\x9a\x99g>m\xa9g\x9e\xa6\x0e\xb4MDE\xf1UE\xd1\xed\xb0\xb7?:\xbbP@j\xd3\x7f\
\xdc\xbe\xb5O^\xe4\x9c\xbc\xb8\xca\xa9\xc7\xd6\xc8z){\xd7\'\xa8\n\x02t\xcb.E\
7#\xcd\x12\xf2"!q\x8e\xbc\x97bI@,M\x15\x98W\x15\xd69\x0ef\xfbK\x0b\x05|\xe3\
\x89\xdf\x7f{\xeb\x7f\xb7\x1b5B\xe2\x1cX\xe8\xadu\xd8\xb8\xb0\xcc\xee\xd5\
\x111\x04\x8cq\x87?6\xa0(\xaaBVdT\xe39\xd6\x19\xb2<\xa77\xe8QM+\x92N\xb2\xbc\
P\xc0\xa5K\x97\xa6\x84\xf4\x9fL\x02!(X\xd0h\xe9\xac\x17$Y\xce\xf8\x939\xdd\
\xb2 \xb6\x82F\xc1\x18s\xd8\xf0\x1c8\xeb\x0e\xdf\x07Q\x9cM\x0e;\xf5\xf2\xd2b\
+\x00\x10\x1a\xff\xe6`\xad\xa4\x1e\xd58g1(F\r\'\x1eYb\xf7\x93\x03VO.S\xcfZ\
\xa2\x08`\x91\xcf:vP$FD\x04\t\xa0\x15\xcc\xdbIv\x94\x1c\xee\xfa4\xfa\xab1\
\x18\x0e\xca\xa2\xe7\x88\x1a\x0f\xfb\x00\x06\xa9,67\xa46\xc7\x9a\x14$`0\xa0\
\x8a\xc5 ^\x89M$\xcc\xc1\x18!\xaa\xe02\xe8\xf7\x87+\x0b\x07\x04\t\x0fX\xdb!\
\xcd\xa1\x9eT\x14\x9d\x02\x99\x81\xb6\x8erP2\xdd\x9a\xa3"\x185$6\xa2Q\x10\
\x14\xe3\x80D1\xa9\xc1x\xc1\x18\x879\xe2|~\xacG\xc8\x16\xf6\xd4\xfa\x03K\xa8\
U\xca\x95\x0eMh\x99Mjf\xf5\x94\xa2\x9b\xa1*\xb8$!\xb4\x1e,\x98\xcc\xe1\xb2\
\x844K\xa9\'-DA\xe50\xef\x10BX8 /\xb2G\xfa\xbd\x1e\xd8\x88xa\xe9\xfe.\xbd\
\xfb2\xf2NJ\x9a\x1d\x8e\xba1\x06\x9ai{\xb8\xb5\xc6\xc3\x8b\xc4\x10\xdbH\x8c\
\xa0jP\x11\xda6\x1c,\x1c\x10b{\xd2G%\xcd2\\fQ\x0b\x88%\x86Hl\x84\xb6\nH8<\'\
\xf9Y\xc49\x8bK\r\xa0\xa8\x18T\r\xa8 \xaa\xf8F\x17\x0bx\xe3\x8d7\x1c\t\'$x\
\x06\xc3\x12\xd4`\xac\x92\xe4\x0e\x97$$\x89\xc3%\x86\xa6\xf6x\x1f\x98\x8ej\
\xday\x8bQ\x83q\x87\x08T\x0fg\x86:0\xdd\x9b\xdc^(`w\xf7\xe3\x8d\xb4tV\x82\
\x92\x17\x05\xb1\x11\xac\xb1(\x87\xf3\xb1\xb1\x96\xa2_\xd0\x1d\x16\x0c\xd7z\
\x84\xb6AD\x99\xed\xcf\xa15\x84F\x89\xcd\xe1\x8c<\x9f\xd6\xac\xafl|\xbcP\xc0\
O\x7f\xfa\xb3\xf5\xfeR\x81\x04\x88\xad\x12\xe6\x11i\x14m\x00\x0c1DT\x04\x8cP\
.\x97\xe4\xdd\x9c,OH\xcb\x8c|\xe00\x89\xd2\xb65\xf5\xa8e\xe7\xd6\x983\x1bg\
\xde](\xe0\xce\xee\x9d\xd5,\xcd\xf1u \xcbSH\xc0\xe6\x06r\xb0\xceP\xf4r\x8a\
\xe5\x0cEA \xc9,8\x83u\x06\x97$\xe4E\x8a\xcb\x13zK\x1d\xcanq\xe7\xf9\xe7\x9f\
\xdf;J\x1eG\xee\x03+\x83\xe1Y\x9b%Xg\t>\xa2r8\x91\x89\x17\x92<\xc5\xf5\x12\
\xbaK9\x8a\xe0\xac\xc37\t\x1a\x15\x9b\x1aB\xe3\xc9:\x0e/\x82o\x03\xaa\x0b\
\xfcc\xeb\xb3hM\xdbu\x99#\x86\x88\x9f\xb7\xf8*P\x8f=~\xeeq\xe2(W:\xac\xdc\
\xdfg\xe5L\x9f\xa4p\x9cxd\xc8\xea\xc62\xea\x0f\xdf\x95|\x90 \x08\x12\x94f;\
\xfe\xe4\xa8y\x1c\xb9\x02\xc3\xfeJI\x84 \x87Gb\xa3\x96~\xb7\x8fD\x83\xa8A]\
\xcd\xf0\xa1\x12\xb9&t\x97\n\x8c\xb5\xf8q`\xa5\x18\xb0wcLf2\xac\xb5\xec\xde\
\xde\x0f\x0f\xdd\xff\xc8\xdf-\x1cPU\x95\xf4f\x16\x9bZ\xc4\xc0\xc3\x17\x1e\
\xa4{_\xce~\x9c\xb0r\xaedzP\xc1\xd8\xb1\xfe\xd0\x10?\x12|\x12h[\x8f\x99\xc2\
\xfa\xc3C\xee\\\xddG\x15T\xf8\xe7\x17^x\xe1\xceQ\xf38\xf2#4\x1b\xcf\xf6\xea\
\xb6\xc2&\x96\xe5\xd5%B\xf0\x98L\x19lvq\x99e\xf5\xdc\x80\xbaiX\xd9X\xa2\x7f\
\xba\x83x\x81\xa0t\x963\xd2\xae\xc3\xe6\x96\x83\xad)i\x93\xbfx\xd4\x1c\x8e\
\x05\x10\xdak\xf3y\x83K\r\xbd\xf5\x9c\xac\x93 A\xc8\xb2\x84r\xbd\xa0\x1d\x07\
\x84\xc0\xd6\x8d}\xc2X\x99m\xb5\xf4\xd7\xbb\xe4\xab9A\x84\xd4%\xccv\xab\xcb\
\xaf\xbe\xf4\xfa\x8f?\x17\xc0\xd7\xbe\xfa\xf5+\xd2*\xc50\x075\xf8\x18I\x9c\
\xa3\x9a{\xa4\x01i\x95|\x90\xd0\xd94\x84\xa2\xa2<\x992\x1b\xd5\x84:2\xbd\xdd\
\xb2}sO\xda\x99>m\x8c\xd1\xcf\x05\xf0\xdcs\xcf\xdd\xf6\x13\xf9P\x8d\x12\x9aH\
\xf0\x11\xbcRt\x1d\xfb\xbf\x18\xd3[/\xd8\xb9:\xa1\xad\x84\xb6\x8a\xb84\xa1\
\x9d\x04v\xaf\x8e\x99\xeeM\x08;\xe6/\xdf\xfc\xdb7\xff\xe38\xc9\x1f\x0b\x000\
\xdb\x9a\xfeuuP\xd3V\x91\xee c6\xaaQ\x15\xe6;5\xb1\x15\xd2"e\xe7\x83){W*\xa6\
\xd7*&\x9f\xd64\xd3\x86\xbd\x8f\xaa\x7f\xfb\xc6\x13\x7f\xf0\xecq\x93?6\xe0\
\xb1\xaf\xfc\xe6\x8f\xb6?:\xf804\x02\xc62\xd9\xab\x98\xed7\x14\xc3\x8c\x9b\
\xff\xb5\x87D\xa5\x9e\xb5\xa8S\xe6\xf3\x8a\xdd\x8f\xf7\xd9\xfe\xf9\xe4?/\x9c\
\xba\xf8{O>\xf9d{/\x00\xc7\xfaN\x0c\xf0\'\xdf\xfc\xe6\xc3>\x1d\xff\xeb\xa9\
\x8bk\x9bE\x91\xe0\xdbH\x9eg(B5n\xe9.\xe7\xa8\x87\xeb\xef\xdf$o;\xaf\xfd\xc6\
W\x7f\xfb\xdbO=\xf5\xd4\xfc^$\x0f\xf7\x00\x00\xf0\x9d\xef}\xe7\xec\x8dk\x1f\
\xfd`\xe9t\xf9\x87\xbd\x95\x9e\xf1\xde\x93\xa6\tQ\x02\xf3\xbd\x86\xe9\x9d\
\xfa\xfd\xd2\r\xfe\xf4\xf5\xd7_\xff\x87{q\xbf_\x8d{\x02\xf8,.]\xbat\xfe\xca\
\xf5+\x8f\'69\x9f\xe7y\x9cM\'\xbf<{\xea\xc1w^y\xe5\x95\x9f\xdd\xcb\xfb|\x11\
\xff\x9f\xe2\xff\x00\xe5\x90~n\xbb\xe2\xcf\xfa\x00\x00\x00\x00IEND\xaeB`\x82\
' 

def getToolPanel_GizmosBitmap():
    return BitmapFromImage(getToolPanel_GizmosImage())

def getToolPanel_GizmosImage():
    stream = cStringIO.StringIO(getToolPanel_GizmosData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_MenusData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x05\xfbIDATh\x81\xed\x99\xcfoS\xd9\x15\xc7?\xef=\xfb\xf9W\x8cI\xe2\xc4\xc9\
\x84dR\x92\x89\x11\xa1H\xadfD\x10\x055\x91\x10\x96\xa0\x1b\xc4\x02\xb1\xa6\
\x9a\r\x9a\xc9\xb2\xffA\x17,f\xc9\x8a\x05\xab0R\x917\x08"\x05\xa9\xa5#\x15$C\
\x08T\x94X\x98N\x921\x1e[ib\xc7?\xb0c\xbf{\xef,<\x99\x1f\x8c\x9dxb\x874\x12\
\x1f\xc9\xf2\xb3}\xdf\xb9\xe7\xfb\xee9\xe7\xfe\xb0\xa6\xe9\x06{\x19}\xb7\x1d\
h\x96\xf7\x02v\x1b[\xad/\xb3k\x19\xf5\xae\x1di\x94}\xbe\xfd\xdaO?\xd7\x14`\
\xb7\xdb\xc9\xe6\xdf\xf0\xe5W/Y\xc7\x81n\xd4l\xf6+Q\x04\\\x16\x7f:6\xd4\x02[\
?R\xd33\xa5\x14\xb9b\x85\xaf^\xdb\xb19\xdd-\xeb\xcc\xabJ\x9c\xfdD\xb6\xcc\
\x1e\xd4\x11\xa0i\x1a\n\x10\x124\xd9\xba\x0e\xa5\xa6\xa3Tk\xa3\xb3~\x12+\x85\
\x94\x02!\x04\x83\x1d&\x9f\x9e\x0c\xe0uh\xfc\xe5L\x1fJJ\x06;M\xbc\x0e\x8dv\
\x97N\x9f\xcfN\x87[\xa7\xdd\xa5#\x85\xa0\xdd\xa5\xd3\xe3\xb5\xf1\xe7?\x04\
\xf0{\x0c\x84\xa8\xda\x91R\xa2\x94B)\xc5\x93\'O\xb8r\xe5\n\xa9T\x8a\x0b\x17.\
 \x84`vv\x96T*E<\x1e\xe7\xf9\xf3\xe7,--\x11\x8f\xc7\x91R\x12\x8f\xc7\x89F\
\xa3\x8d\tPJ}?\x02\n!$BJr%\x8b\xdf\x0f\xb4\xb1\xb0R\xe2w\xfd\x1e\x02^;\xa7\
\x0f\xb73v\xd0\x8b\xa1+N}\xe4c\xec\xa0\x17\xa9\x14c\x07\xbd|\xb3Zbv1\x87\x90\
\xb2jC\xc8\x9f\tPJ\xe1\xf3\xf9\x98\x9e\x9e\xe6\xf0\xe1\xc3LOO\xf3\xea\xd5+\
\xae_\xbfN8\x1c\xa6X,255E8\x1cF\x08A8\x1cfxx\xb81\x01\x9a\xa6\xa1\x94BH\x81\
\x90\xd5\x8e\xe7\x96rXB\x92yS\xc1a\xd7\x90R\xf2\xefx\x0e)\x15/\x93\x05\x8aeA\
\xa9,h35\xf6\xbb\x0c\x84\x14(%Q\xb2\xfa\x006^?\x15p\xea\xd4)\x00:;;\xc9f\xb3\
(\xa5\x18\x1b\x1bC)\xc5\xd1\xa3Gq\xb9\\8\x1c\x0e\x96\x97\x97I&\x93d2\x99_\
\xf8Z7\x89Q \x85\x02!\xf96\xb3\xcer\xb6\xccj\xa1\xc2\x87\x9dN\xbeY-\xf1\xf1o\
\xf6\xb1^\x16D\xbe^\xc3\x12\x92G_\xaf\x91\xca\x96\xf9xp\x1f\xff\x8ae\xe8n\
\xb3c74>\xect\x12_-\x01 5\x85\xfc>\xa7\xfa\xfb\xfb\t\x04\x02LLL0??\xcf\xc8\
\xc8\x08333\x98\xa6\xc9\xc4\xc4\x04\x00\xe3\xe3\xe3\x0c\x0c\x0cp\xef\xde=B\
\xa1\x10+++5\x1ev\x8d\xb5\xd0\x9bB^-\xa5\xd2|6\xf5_4\xbb\xb3\x96\xc6m\xd1a/\
\xf1\xc5\xc5\x8f\x9a\xb2\xd1\xd3\xfb\xc1\xd6\xf3\xc0\x8f!$\xd1d\xeb\xaa\xc6F\
\x08\xb5\x92\xba!\xd4fW\xfc\xf5L\x1b\xaf\xd3Et\x9b\xb9\xed\x0e|.\x03\x8fM\
\xd2\xdd\xdd\r@\xb9\\\xde\xb6\xadZ\xd4\x1d\x01\xd34YHW\xf8\xdbK\x0f\xbaa\x07\
\xadV\xcb\xad\xe9\xd4\xb2|\xfeG?\xed\xed\xed\xcd\xf8Y\x97M\xd7\x08ei\xa0\xd9\
]43\xe8\x15\xa3u9T\x8b\xfaU\xa8z\x85\x10\x82n\xaf\x1d\xaf\xb3\xda\xf4\xd5rqS\
\x83\xc1\x1e7#\xdd.n?[A\x01Rk\xed\xd2\xe1m6\x1d\x01\xa5@\x08\x89\xcb\xd4\x08\
\x06\x9c\xf4\xb5;p\xd8\xa0\xd7g\x92_\x17tx\xecd\x8b\x16\xbd>\x93\xe5|\x85\
\xc2\xbadv)\xc7H\xc0\x89%e\xb5\x14\xeb;\xbb\xb0\xad;\x91m(\x10B"\x85b9Wf\xfe\
\xdb\x02C]NJ\x15\x89ih\xe8(\xeeG\xd3\x94*\x92\x7f\xcc\xa7\xe9p\x1b\x94\xd6\
\x05\xc2\x92\xc8\x1ff\xdf]\x10\xb0\x81\x02\x84\x10\x14J\x15\x92\x99\x12\xfb\
\x9c\x06\xb3\x0bY4\x14\x89t\x89\xd4\xda:\x96%HfJT*\x82\xe5l\x99C=.|n\x83`\
\xc0U]\xff\x88]\x08\xa1\x8d\x1cP\n,!Y\xfc_5\xee\xff\xf3:\x0f\xc0|"\xff\xb3\
\xf6\x7f\x7f\xb1\n\xc0?\xa3\xd5\xf7\xa7K\xd9\x1f~\x93j\x17\x04l\x84\x90\xae,\
\x84\x00\xb4m\xd6P@Y\xeb\xdb\xbe\xb7\x116M\xe2\x13\xbf\x1d\xc0\xdfUD\xe9\xf6\
m\x19\xd7P\xf4\xee\xff\x00\xd4\x9bm\xdd\xdf\x08\x9b\x86\x90\xc7ir\xe6\x93\
\xbe\xa6;\x89\xc5bM\xdb\xa8\xc7\xe6Uh\x0f\xd0\xd0n\xfd\xf1\xe3\xc7<z\xf4\x88\
T*\xc5\xe4\xe4$/^\xbc \x18\x0c\xb2\xb6\xb6F:\x9d\xc6\xef\xf7\x93L&\x19\x1a\
\x1abnn\x8eX,\x86\xc7\xe3\xe1\xd2\xa5K;\xed\x7f\xfd\x1d\xd9\xdb8\x9dN\xdcn7\
\xb7n\xdd"\x91Hp\xed\xda5n\xdc\xb8\x81\xae\xeb\\\xbdz\x15]\xd7\x99\x9a\x9ab|\
|\x9cc\xc7\x8ea\x18\xef\xe6\xc8\xb2\xe1\x10\xf2x<\xf8|>\n\x85\x02\x9a\xa6q\
\xf2\xe4I\xdcn7G\x8e\x1c\xa1\xbf\xbf\x9f\xd1\xd1Q,\xcb\xe2\xe9\xd3\xa7D"\x11\
\xce\x9f?\xbf\xe3\xceC\x83#088\xc8\x89\x13\'\xe8\xea\xea\xe2\xe2\xc5\x8b(\
\xa5\xf0x<\x84B!4M#\x14\na\xb3\xd98}\xfa4\xf9|\x1e\x87\xc3A$\x12y\'\x02\xea\
\xee\xc8r\xb9\x1c\x00]]]Mw\x12\x8b\xc5\xe8\xe9\xe9i\xda\x0e\xfc\xf2dn\xcfW\
\xa1\x86\x93\xf8\xff\x95=\x7f:\xddP\x08\xad\xac\xac\xb0\xb8\xb8H<\x1e\xdf\
\xd2\xe0\xb3g\xcf\xb8y\xf3&\x89D\xa25\x1en\xc1\x16;\xb2*\x0b\x0b\x0b\xdc\xbf\
\x7f\x9f\xf9\xf9y&\'\'\x89D"\x1c:t\x88D"\x81eYX\x96\x85R\x8a\xe1\xe1aFGGI\
\xa5R\xdc\xb9s\x87\xcb\x97/\xef\xb8\x80\x86\x93\xf8\xc0\x81\x03\x1c?~\x9c\
\xdb\xb7oS.\x97\xb9{\xf7.\xd1h\x94\xb3g\xcf\x12\x8dF9w\xee\x1c\x0f\x1f>\xc4\
\xe5r\xd1\xdb\xdb\x8b\x10b\xc7\x9d\x87_\x91\x03n\xb7\x9b\xb9\xb99\x82\xc1 P=\
5\xb3\xd9l8\x9dN\xda\xda\xdap8\x1c\x00\xcc\xcc\xcc\xf0\xe0\xc1\x03\xfc~\xff\
\xcex\xfc\x16\xef\xe7\x81\xddf\xcf\x97\xd1\xbaU\xc84M\x92\xc9$\xab\xab\xabMw\
\xe2v\xb7\xeeo\xaa\xb7\xa9\xbb\'6\x0c\x83\xbe\xbe\xe6wc;\xcd\x9e\x0f\xa1\x9a\
Uh/\xb1\xe7G\xe0\xbd\x80\xdd\xe6;Y\xee\xce\x7f\x10\xcca\xb0\x00\x00\x00\x00I\
END\xaeB`\x82' 

def getToolPanel_MenusBitmap():
    return BitmapFromImage(getToolPanel_MenusImage())

def getToolPanel_MenusImage():
    stream = cStringIO.StringIO(getToolPanel_MenusData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_PanelsData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03\xd9IDATh\x81\xed\x99OH2[\x18\xc6\x1f33\x03CC\x8c\nZ\xf4\x7fQJA\xd2&\xd4\
\x8d\xb8h\x19\xb4p#Q\x04E\x06\x11\xb4\xbdw\xe1"\xb0V\x05A\x11\xb40\x17\xe1\
\xdaMP.B\x08\x0cmQ\x0b!\xc8\x16\x19\r\x1a\xce`\xc34\xce\xb9\x9b\xeb\x90\xdf8\
\xdd\xea\xda\xe7t\xaf?\x10\x99\xf7\xbc\xe0\xf3xf\xdes\xce;@\x9d:\xffoT\xbf\
\x06\x0e\x0f\x0f\xff\xa8\x81\x0e\x11A\x10\xce\x0c\x06\x83\xe3\xe2\xe2\xa2,\
\xde\xda\xda\n\xb7\xdb}6::z\xf66.1\x90H$\x88\xd5j\xfd^\x95\xef\x10\x0c\x0610\
0\x80\xbe\xbe>\xf0<\x0fA\x10 \x08\x02\xf2\xf9<\xe2\xf18<\x1eO\x99\xe6\x86Z\t\
\x95\xe3\xf1\xf1\x11\xc3\xc3\xc3P\xa9\xca\xff[\xadV\x0b\xb5Z-\xc9W\x9c\x01\
\x00\xa2\xf8l6\x8b\xcb\xcbKI\xfc-\x8d\xbfM\xd5\'\xa1i\x1a\xb1X\x0c\x1c\xc7A\
\xab\xd5\xa2\xa7\xa7\xa7b\x9e\xec\x0c0\x0c\x83h4\xfa\x8f?\xb4\xb0\xb0\x00\
\x9e\xe7\xbf\xaeT\x06\xbd^\x8f\xe9\xe9ix<\x1e\xd8l6h4\x9a\x8ay\xb23\x90\xcf\
\xe7qrr\x82\xa3\xa3#tww\xe3\xf6\xf6\x16^\xaf\x17&\x93\t\xdb\xdb\xdb\xe8\xec\
\xec\x84\xdb\xed\x06\x00\x04\x02\x01\xa4R)x\xbd^LNNV\xcd\xc4\xcb\xcb\x8b\xf8\
\x10\xbf\xbe\xbe~\xce\xc0[VWWAQ\x14\x0e\x0e\x0e\x90\xcb\xe5\xe0\xf7\xfba0\
\x18\xc4\xf1\x95\x95\x15q\xbc\x1a\x06\xa2\xd1\xa8X\x81\x08! \x84\x80\xe7yd2\
\x99\xaf\x19\xd0h4P\xab\xd5\x10\x04\x01\xbd\xbd\xbd\x88\xc5bp\xb9\\`\x18F2^\
\r\\.WY\t\xe5y\x1e\x85B\x01\xe7\xe7\xe7\x92\\\xd9g@\xaf\xd7\xc3\xe9tbjj\n\r\
\r\r\xd0\xeb\xf5p8\x1cXZZB.\x97C \x10\x00EQ\x92\xf1\x9a\x93H$H-\xd9\xdc\xdc$\
\x82 \x10\x8e\xe3\x08\xcb\xb2\xa4P(\x90|>O2\x99\x0c\t\x87\xc3\xe4W\xbd\x8a\\\
\x07>\xc3\x8f7\xa0\xd8\x85,\x9b\xcd\x82\xa2(\xf1\xdad2U\xccS\xac\x01A\x10P,\
\x16A\x08y\xb7\xba)\xd6\x80\xd9l\x86\xd9l\x16K\xe9\xf3\xf3s\xc5<\xc5\x1a\xa0\
(\xaa\xba\xb7\x10\xc30\x88\xc7\xe3\xb0\xdb\xed\xff^\xdd\x07hkk\x83\xc1`([\
\xc8*!k\x80\xa6iD"\x11\xa4\xd3i\x8c\x8f\x8fcll\x0c\xc5b\xf1\xdb\x04\x7f\x15\
\xd92J\xd34\x82\xc1 |>\x1fvvv@\xd34NOO\x7f\xa7\xb6\x0f\xf1\xee:`\xb1X\xd0\
\xd4\xd4\x04\xa3\xd1X\xb5}N\xb5\xf9\xf1\x0b\x99\xe2\x0e\xf5[[[\xb0X,b\xfd/}\
\xf3<\x8ft:\x8d\xe5\xe5\xe52\xcd\x8a,\xa3\x1d\x1d\x1dhll\x94\x9c\x81Y\x96\
\x95\xe4\xfe\xf8[\xa8n\xa0\xd6\xd4\r\xd4\x9a\xba\x81Z#\xbb\x0e\xb0,\x8b\xf9\
\xf9y\x0c\x0e\x0e\xc2n\xb7\xc3j\xb5bww\x17777X\\\\\xc4\xfe\xfe~Y\xc3\xab\x9a\
\r\xad\xcf k@\xa5RA\xa7\xd3\xa1\xb9\xb9\x19###\xe08\x0e:\x9d\x0ef\xb3\x19\
\x91H\x04@y\xc3Kq\x06\x00\xc0\xef\xf7\xe3\xfa\xfa\x1a{{{\xc8d2\x98\x9d\x9d\
\xc5\xfd\xfd=b\xb1\x18\x80\xea7\xb4J<<<\x94m%\xc8\xdf\x9d\xb9\xa7\xa7\xa7\
\xcf\x19\x08\x85B(\x16\x8b\x98\x9b\x9b\x03M\xd3\x08\x85B\x18\x1a\x1a\x82\xc3\
\xe1\x00\xc30\xdf\xd6\xd0r:\x9d\xe2Q\xb2\xf4aY\xb6\xe2yD\xd6\x80V\xab\x85\
\xcf\xe7\x13\xaf\x8dF#\xd6\xd7\xd7%y\xa5\x0e^\xadPl\x15J\xa5R\xe8\xea\xeaBKK\
\x0b\xd6\xd6\xd6d\xf3\x14k\xa0\xbf\xbf\x1f\xe1p\x18333\xd8\xd8\xd8\x90\xcdS\
\xe4v\xba\xc4\xc4\xc4\x04l6\x9b\xf8~\x80\x10IkTy3\xd0\xde\xde\x8e\xab\xab+I\
\x9ceYp\x1c\'\x89Kf \x99L\xfe\x99L&\xbfG\xdd\x07\x10\x04\xe1\xec\xee\xee\xce\
q||\\\x16/\xbd\'\xae\x8d\xaa:\xffa\xfe\x02K^L<\x0eSEl\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getToolPanel_PanelsBitmap():
    return BitmapFromImage(getToolPanel_PanelsImage())

def getToolPanel_PanelsImage():
    stream = cStringIO.StringIO(getToolPanel_PanelsData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_SizersData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x00\xd2IDATh\x81\xed\x97\xcb\x0e\xc3 \x0c\x04Y\xe8\xff\xffq\xe2^z\xa0\xa8\
\xe1\x11\xc0\xdbH;W\xc2\xc2H\xc1\x18 \xa6\xf0d"{\x03\xb3H\x80\x8d\x04\xd8H\
\x80\x8d\x04\xee`\xe7a\xab\xb2\xdc\x05\xec<\x0c1a\x95\x04Z\xad\xc49\xb1P\x8c\
\te\x0e\xb2\xf1\xde\xe0<\xa7\xe4\xd5\x95`\x17K\x01\xf5\xb1_9@0\xb3\x80|\xeeh\
N\x86\xff/\xf4\xd9\xa8]mx\x10U!6\x12`#\x016}\xf7@\xad\x167\xea\xf4\x96\x9c\
\xafiz\xd4s\x91\x00\x9b\xe6!^\xdd\x8d\xce\xe6\x94\xf8w\xa3\xa3\xfc[7\xba\x1a\
\t\xb0\xe9;\x03\xab\xb8y\xdb\xd6\xf0\x15(\x0fq\xad\x08\xe4\xdfT\xf0\xed\x856\
\xe0[F7\xf0\xf8C,\x016\x12`\xc3\x7fRNV+=)\xd9H\x80\x8d\x04\xd8H\x80\xcd\x1b+\
\x02>\x89d4]\x8d\x00\x00\x00\x00IEND\xaeB`\x82' 

def getToolPanel_SizersBitmap():
    return BitmapFromImage(getToolPanel_SizersImage())

def getToolPanel_SizersImage():
    stream = cStringIO.StringIO(getToolPanel_SizersData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPanel_WindowsData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x000\x00\x00\x000\x08\x06\x00\
\x00\x00W\x02\xf9\x87\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03BIDATh\x81\xed\x9a\xcfk\x14g\x18\xc7?\xef\xcc"\xee\x12I\x85\x98MU(m%q\
\xd5-\x08\x9a-=\x15\xbd)\xa5\xa5Xj\xf0\xe8\xd5\x83\xa0HO=x\x92\x90\x83\xf8?\
\x98\x14\x04A\x88\xbd\x99S\x7f`mR\x95\xb2\x96\xd2\x90\x1f\xd2hT\xdc\xcd*ag\
\xe6\xfd\xe1a~$\xc1\x9d\xc9\xc6D\x86\x85\xf9\xc2\xb0\xb3\xef\xf3\xe5y\x9e\
\xcf\xfb\xbe3\xb3\x0c+\x84e\xd3\xc9\xb2\xd2n`\xb3\xca\x00\xd2V\xc7\x03\xe4\
\xda1]\x19\x1e1\xef\xbb\x91V\xfa\xe1\xd2E\xb1\x9e\'\x11\xe0\xce\xc4\x84\xb9z\
\xf3\x1es{Om]W\x1b\xd0W\xe7\x949\xff\xedQ\x8e\x1f;\x16\x0b\x92\x08p\xf5\xe6=\
\xb6\x95N\xf0\xac\xf6\xaa\xed\xa2\xcd\xda\x02;t#6\xae\x0b=\xa8|O[\xbem\xa5\
\x13\x9c\x1f\xb9\x96X/\x16\xe0\xca\xf0\x88\xf9\xaf\xef\x1b\x16_\xfa\xcd;\xff\
?D\x88\xb7/\x19i\x04\xf9=\x07\t\xa7H\xbf~\x86\xbdo0\xb6\xe0\xe2\xdf\xbf\xf0\
\xc9\xe1\xbd,<n\xcfW\x1c<\xc5\x99/\x07L\xdcvJ\\\x01\xa55\xae\'\x01\x18\xfc\
\xe0%;v\xf6 \x84\x85eY\xc1\xa7\xe0\xd1\xbf\xd3\xcc4?\xc5\xb2\xfdT\x16 \xa5\
\xe4\xc0\xee\x02\x07>,D\xb9\xaaO\x96\xa9.,\x079\x95\x0f\x1f\xf8\x00\xaa\x0b\
\xcbk\xceC\x9f\xd2:\xa9\xc5d\x00\xa3\rZ\xf9\t\x8e\x7f\xfe\x19\xfd\x03\xfd\
\xd8\x96\x8d\x9d\xb3\xc9\xe5r\xd8\xb6\xcd\xed;\xbf2\xfd\x8f\x06t\x04\xe0J\
\xc9@\xefv\xa4RQ\xae\x81\xde\xed\xdc\x9fo`\x8c\x89\xc6])\xf1\xa4\xe4\xf2\xd7\
\x1fs\xe3\xcf\xe7|wd\x17?\xde\x9a\xc1\x952\xf2\x99M\x01`\xd0\xc6O \x84\xc0\
\xb2,,\xdb_\x81\xf0\x10B\xa0\xb5\x06\xb1RHJ\x89\xd2\x9a\x9f\xfex\x1a\x8d\x9d\
\x1e\xecC\x06\x8d\xa9`R\xa4\x94<\x98o0vw\x91\xa1J\x91\xb1\xbb\x8b<\x98\xf7\
\xaf\x8b\xd0\xb7\xde\xed/\xf19`\x8c\x0f\xa0\x8dFXbM\xe3\xab\x01L\xe0\ta=O\
\xa1\xb5\xc6\xf3Tt\x84\xdf\x8d\x01\xa9V|\xa5\xbe\x02C\x95"\xd7\x7f\x7f\xc2P\
\xa5H\xa9\xaf\xb0\xc6gL2B\xf2\n\x18\x7f\x1b\x01\xfc6Ue\xf6i-h\xdc\xc6\n\x80\
\xfe\xaaNcL\x19\xf4J!OJ\xa6f\xeb\x9c\xae\x14\xa3\xb1\xa9\xd9:\x9e\x94\xb0j\
\x05\xbc`\x0b]\x18{\xc4\xc3\xc7\xaf\x98\x9a\xadG\xe3\xa1oS\x00h\x85Q\x1e\x00\
?\xd7\xfb\xa1\xde\xca\xb4\x1f\xcb\xd6\x91/l`r\xa6\xc6\xe4L\xad\xc5\xa4(d\xe0\
\r}\xa1V\x9fG>\xad\xde\xca\xd16\x80\xd1\n-\xdd\xc4\x04\x00Z\xae\xec\xff&y\
\xdc\xb9\xc9Xo\xf7\xee}4\xea5rm\xfa\xcc\xa6\x00\xa4\x83n\xc6?lZ\xc9\x05\xba?\
:\x14\x1b\x7f\xdd\xa8\x03\xcd\xb6}(\x99X/\x16\xa0\xbb+\xcf\x17\x859*\xa5\xe4\
\x04\xad\xf5">\xb4gc>\xa7\xe9\xd0E>\xd6\x96\xb8\x02g\xbf?\x89\xeb\xae\xbf\
\x85\xde\xa7\x96\x96\x96\x18\x1f\x1f\x8f\x8dw\xfc\xcf\xe9\x0c me\x00i+\x03H[\
\x19@\xda\xca\x00\xd2V\x06\x90\xb62\x80\xb4\x95\x01\xa4\xad\x0c me\x00i\xab\
\xe3\x01\x12_\xab8\x8eC\xa3\xb1\xb1\x17[[-\xc7q\x12\xe3\xb1\x00\xe5r\x99\xd1\
\xd1\xd1-o\xe8]T.\x97cc"\xfb\xabA\xca\xca\x00\xd2V\xc7\x03\xbc\x01\xa9\xe9\
\xb7\xb4\x0c\x07\xfdW\x00\x00\x00\x00IEND\xaeB`\x82' 

def getToolPanel_WindowsBitmap():
    return BitmapFromImage(getToolPanel_WindowsImage())

def getToolPanel_WindowsImage():
    stream = cStringIO.StringIO(getToolPanel_WindowsData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPinData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x18\x00\x00\x00\x18\x08\x06\
\x00\x00\x00\xe0w=\xf8\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x02\xf5IDATH\x89\xed\x95]HSq\x18\xc6\x9f\xffvv\xdc\x98v6\x9d\xf3\xe8\xd6\
\x96V\xa2\x0b\xd4hV\x92\x8az\x91\x82\xda\x07\x15tU\x17EW\x11]\x15\x11\xd1\
\x8d\x05]\xd5E7\xd2mEhI\x18J\xa6Q\xa4h\x89-\x95e\xba\xfc\xce\x8fm\xee{s\x9fg\
\xe7t%\x14\xe4\xe6\x07\xd1M\xcf\xe5\xfb\xf2<\xbf\xf7\x85\xf7\xcf\x1f\xf8\x97\
\x8av==$\x98;\r\x82 \x88\xb6\x9aA\xd6k\x08\x03\xef\xf7:\x9b\xaeN\xc8B3Dd,\
\x08\xa3\xe4\xc4p$;\xb7_\xae\xcb}G\xe5e\xbf%D\x17\xda\x1e\xc0d\xca\xf4\x0fvZ\
\xe2\xb6^E\x1a\xe5\x02h\x05\x04\xbf\x15q\x8a\x83`\xa8\xf7\x82Q\xb5K\ruO\x90S\
\xdcC\x08\x89o\x1a\x00\x00\xc2\x9ce\xb7\xdf\xe5x\xc6-M\x18a\x9f\x04\xed\xf9\
\n\x19\xef\x82\xe0\x9d\x07\x026De,D\x85U3D_~\x87.\xafxLH~dS\x00\x00pXF\xb4\
\xd2\xa9\x811i`)-\xee\xfc\x8c(\xc5\x00\xeeE\xd0\x9c\x0f\x12a\x15\xbc\xdb\x0e\
>@\xc0i\x0eN\x8bJ+\xafKko>\xdf\x14\x00\x00&\x1f^kNu~\xbb$f\xb5\x80T\x02\x04\
\xe7 \xc4\\\x88\x12\x16\xf1\x08\x07\x19\xb7\x0c\xcc\xdb\xc19\x80\x80\xf1\xcc\
\xe9\xfck\xf7^\xacy\xa9\x8d\x00\xac\xb4*:\xdc\xfb\x03euZ\xa8( \x95\xca\x84D\
\x91\x03*\xe4BJa5\xec\xe1\x1d\x10e\x8c\xfb=c\xa6\x0f\xcc\xae}\xa6_\xbd\x1b\
\x02\xe8\xf4\xaa\\_\x95\x11\x13V;\xc6\xad1D\x97\x17a\xc8Q\x80\xd5\xaagS2s\
\x1f\x08\\\xfaK]\xfd\xf9y=!\x02\xee\xbf\xf9\xcd\x9b\x14`\x1d\xe8\xc9Z\x18n\
\xad,=\xde\x08q\xd0\x81\xd5p\x10+6\x1b\x9c3s^0\xfb\x1a\xf4\xc5\x8d_\x13\xf9\
\x13_Q\xc0\xbd\xdf1\xfc\xfa\x15\xbd\xd0\xa5\xf1Dy\xc4\xb8\x18\xd4EU\x883,\
\xc2!\xbe)\xbb\xe8\xe4\xadd\x03\xfeq\x03\xeb`w^\xe4K\xdb#\xffH\x9b\x96w/i\
\x08\x01bq\x1e\x9e\xc59\xa43&x\x1d\x1eh\x1an\xac$\x0b_\x17\xe0\x9d\x1f\xbf\
\xac\x8eYjB\xdf\x83 \x1a#l\xb3>\xf8\xb90"\xc1\x18\xc2\xab>\xc8\xd3UX\x99\xb6\
|\xdb2 ]\xb7\xa7\x99V\xd6\xce\xc8iYm\x8cJ-r\xaf,\xed\x1c\xea\x9f\xc2\xa9\xa3\
,\xd2\xf8e\x88S\xb3\xc0k\xd5\xe7\x00t\'\x03$}\x07\x82w,\xc3\xf2\xa9\xafu\xb2\
\xa7\xebHu\xa9LB\xd3 \x04b\xacF\xc4\xbc\xcb\xc7\x1e\xdbu\xf1n\xc7\xa67\xf8m\
\x02\xc6\xe0\xd4\xeb4\x07\x95\x0c\xd3\xf1\xe5v\xd7\x95\xb8c\xb4\x86_4_p\xf4\
\xf5U\x88U\xfa\r\x9dyB\xb5\xb7?/\xc8\xc8P\xf2\xa3\xbd\xbd\xca_\xeb\xee\xbe\
\x96\x12ahH\xb2m\x80\\.w\x95\x97\x1d\x18\xdfv\xd0zR*\x15\x91\x9e\xce\x96\xb3\
[\xf5\'\xfc\xa9\xa4R\xe9\xc7\xc3\x87\x8d.\x85:\xaf}\xab\x80\x84b\xd9\xac\xfb\
f\xb3\x99\xfe+\xe1\xff\xb5\xa6\x9f\xfbG2\xa8S\x86\x86\x06\x00\x00\x00\x00IEN\
D\xaeB`\x82' 

def getToolPinBitmap():
    return BitmapFromImage(getToolPinImage())

def getToolPinImage():
    stream = cStringIO.StringIO(getToolPinData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getToolPinDownData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x18\x00\x00\x00\x18\x08\x06\
\x00\x00\x00\xe0w=\xf8\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x02\xceIDATH\x89\xed\x93KHTa\x18\x86\xdf\x7f\xe6\xccq&\xc7\x8e:\xa3\x8e\xce\
4\xa3V\xa2#\xa8\xd1hH*\xea"\x03\xb5\x0b\xd5\xb6\x16E\xab\x88VFD\xb4\xb1\xa0U\
-\xdaH\xdb\x8aH\x930\x94L\xa3HQ\x92i\x1c\xc5\xeb\xe4=\x1d\xe7~w\xaeg\xcei\
\x15\x9474\x83\x16\xf5,\xbf\xc5\xf3\xfc\x1f|?\xf0\x9f\x7f\x93h\xf7\xf3c\xfcX\
\x97\x96\xe7y\xc1^]d\xfd\x80\x1f\xfcx\xd8\xd9|cZ\x12\x9a\'\x02]~\x18%g\x8c\
\x91\xcc\x9c\x81Du\xce\x07*7\xf3=!\xea\xd0\xde\x02\x06C\x9a\x7f\xa8\xcb\x14\
\xb7\xf6%\'Q.\x80N\x06\xef\xb7 N\xb1\xe0\xb5\xf5^0\xf2\x0e\xb1\xf6\xe43d\x15\
\xf7\x12B\xe2\xbb\x0e\x00\x00\xbfh:\xe8w9^\xb0\xe6i\x1dl3\xa0=\xe3\x90p.\xf0\
\xde% `ET\xa2\x80\xa0\xa0z\x9eh*\xee\xd1\x15\x95O\t\xc9\x8b\xec*\x00\x00\x0e\
\xd3\x88J<;8!\x0e\x98\x93\xe2\xce/\x88R\x0c\xe0^\x01\xcd\xfa \xe2\xd7\xc0\
\xb9m\xe0\x02\x04\xac\xb2lNPZuS\\w\xbbmW\x01\x00\x98y\xdc\xd4"uN^\x15*T\x80X\
\x04\x04\x17\xc1\xc7\\\x88\x12\x05\xe2\x11\x16\x12v\x15X\xb2\x81u\x00\x01\
\xdd\x85\xf3yM\x0f^\xadwP\xdb\x05,\xb4<j\xec\xfb\x86\xf2\x93*\xc8)@J\xa5A\
\x94\x9c\x05*\xe4BBA\rl\xe1\xfd\x10\xc8\xa6\xfc\x9e\t\xc3\'&\xbb\xd0\xb0\x99\
c\xdb\x80Z#\xcf\xf1U\xeb0m\xb1a\xca\x12Ctu\x05\xda\xacd(T\xe9\x0b\ti9\x8fx6\
\xf5\xb5\xba\xfe\xd2\x92\x86\x10\x1e\x0f\xdfm\xea\xd82`\x19\xec\xcdX6\xb6V\
\x95\x9en\x840\xe8\xc0Z8\x08\xbb\xd5\n\xe7\xfc\xa2\x17La\x83\xa6\xb8q|\xbb\
\xc7\xfd`\xf3+\n\xb8\x8f8\x8co\xdf\xd0\xcb\xddJO\x94C\x8c\x8d!\xbd\xa8\x1aqF\
\x81p\x88k\xce,:{g\'\xf2\r\x1bX\x86zr#\xc3\xedO\xfc#\xed*\xcemV\x12\x02\xc4\
\xe2\x1c<+\x8bHe\x0c\xf0:<P6\xdc\xb2\xefT\xbe!\xe0]\x9a\xba\x96\x1e3\xd5\x86\
\xbe\x06A\x94:X\x17|\xf0\xb3aD\x821\x84\xd7|HL\x95\xc3>g\x9a\xfc\xed@\xaa\
\xfaP\x0b\x9dR7\x9fHK\xeab\x94\xb4\xc8m7\x1f\xd0\x0f\xcc\xe2\xdc\t\x05\x92\
\xb8U\x08\xa5\x19\xe0T\xe9\x17\x01\xf4\xec4\xb0\xe5?\xe0\xbd\x132\xd3\xe7\
\xfe\xd6\x99\xde\xee\xe35\xa5\x12\x11M\x83\x10\x08\xb1\x16\x11r.\x9f\xe2T\
\xf6\x95\xfb\x9d\xbb\xde\xe0\x972\xa3uj\xd4\xca\xb2\x14\x86\xe9\x1c\xbe\xdb}\
=\xee\x18\xad\xe5V\xc6.;\xfa\xfb+\x85r\xcd\xb6\xe7\xbd#::\xda\xf2e\xb2\x14n\
\xb4\xaf/\xe5\xe7\xb9\xbb\xffe\t\xaf\xd7\x8b\xf6\x1c\x00\x80\x8a\xf2\xa3S\
\x7fD\xf4\xd7\xd0\xeb\xf5\xfb\xf6\xea\xf8\x0ed\x0c)\xa2\x9b\x88\xd9:\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getToolPinDownBitmap():
    return BitmapFromImage(getToolPinDownImage())

def getToolPinDownImage():
    stream = cStringIO.StringIO(getToolPinDownData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeBitmapData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x0e\x00\x00\x00\x12\x08\x02\
\x00\x00\x00\xe4>xf\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\x02\
eIDAT(\x91M\x92\xb9kTa\x14\xc5\xcf\xbd\xdf\xf7\xde\xc4qf"\x13g\xc45fqCEQ\x14\
T\x10w\xe2\x06*"h\xa1 \x16\x16b\'\xd8\x89\x7f\x86`a!\xe2R\xba\x82\xe2\x82\
\xda\xc4\rA\x0bu&\x85\xa2&fQ2#yy\xef\xbb\xf7Z$HN\xfd;\x07\x0e\xfc\xa8/\xe93\
\x18\x0053\x98\x99bJ\x88\x98@L\x04\xc0Opb\x1a4\xbb\xfe\xeef3i&Y\x12\xb9(\xf6\
\xb1\xa8\xec[\xb1gni.\xe0\x00\xf8\tn\xa0\xd9\x7f\xb5\xf7\xda\xc1\xd5\x07\xaa\
\x85\n\x00Q\t\x1a\x92\x90\xdc\xf9p\xafc\xe6\xc2\x1d\x8b\xb6;\xf2\xacfI\x18\
\xbb\xda{\xed\xd4\xc6\x93sJ\xb3c\x17G\x1cE.\xf2\xecs>\xb7\x7f\xe5\xde\xfe\
\xd1\x81\xd7\xdf\xdf\xa8\t\xab\xc9\x8dw\xb7\x0e\xaf9\x94\xf3\xb9\x88\xa3\x9c\
k\x89]\xec\xc89vL\xcc\xc4[\xba7\xbf\xf8\xfc\xd2`\x0c \xc9\x92\xf2\xb42\x81\
\x98\xd8\xb3crD4\xf5\\[\xb1\xed\xf3\xd0\x17\x06\x10$\xa8\xa9\x9a\x8aI#m\x04\
\xcd\xd4\xd4\xfe\x07\xd6U\xe9\xac\r\xd5\x18\x80g\'&A\xc3\xe8\xf8\xe8\x93\xda\
\xd3?\xc9\x1fQ\xa9\x8f\xd4\xfb\x1b\xfd\x93\x1d\xd8xH\xbd\xc1\xd4LT\x00\x98\
\x99\x98<\xab?/O\x9f\xd1H\x9a\xd5b\xb5\xd4R\x12\xd3\xc1\xc6PG\xdbB\x06`\xb0L\
\xb3L2\x83\x15r\x85\xc5\xd5n".\xb6\x14\xab\x85J\xd0 *_\x87\xbf\xae\x98\xb5\
\x9c\t\xb4k\xd9\xceG\x9f\x1eg\x92\xa5\x92\xe6\xe3|9_\xee*w\xb6\xf8\x1c\x80\
\xa0\xf2{l\xa45_\xf2\xec\x99\xc9u\x96;DCm\xb8\x9e\x86T4\xa4!\xcd4\x0b*\x99\
\x844\x8c?\xfa\xf8\xe4\xd8\x9a\xa3L\x8e\x010\xb9\x13\xeb\x8e\x7f\x19\xa8\xbd\
\xf9\xf66\x93\x90J\x96J\x164\x0c\xfe\x1d\xbc\xfd\xfe\xee\xc9M\'"\x17\x11\x88\
\xeaI]\xcd\xd4DM/\xdc\xbe\x18\xf9h\xf7\xaa\x9eB\\\xb8\xff\xe1\xc1\xf3\xd7/\
\xaf\x9c\xbd\\\xca\x95\x98\x1c\x81<\x00&\x02\x9c\xc1\xda\xab\xed\xedm\x0bz\
\xfb^\x19\xac{V\x97\xad\xb5b\\\x9c\xe0\x98\xc8\x13hB.&7\xbf<o<\xa4\xdb\x96n\
\xf5\xec\x83\x86\xa1\xe6\xb0c\xef\x88\x01L\xae\x12\x88\tjX\xbf`\xdd\xe9Kg\
\x96v-n\xcd\xb7\xfe\x18\xfe\xb9k\xd5\x8e\xff\x1c\x00\x9eT\x18\xc4D\x95|\xe5\
\xfc\x91s\xbfF\x06\x1f<{\xb8q\xd9\x86\x9e%=SM\xf8\x07b\x08J\xca\xa1\x02\xc5O\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeBitmapBitmap():
    return BitmapFromImage(getTreeBitmapImage())

def getTreeBitmapImage():
    stream = cStringIO.StringIO(getTreeBitmapData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeBitmapButtonData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\xd1IDAT8\x8d\x9d\x92\xdfj\x13A\x14\xc6\xbf\x9d\x99u\x93n+\xd9nb\x8c\
\x94M\xd4\x8b\xd6\x86\xae\x16o\x94^(\xfey\x07\xc1\x87\x10\xef\xc4\xc7\x10\
\x1f\xc46\x8a\x7f\x11\xeb\n\xd5\x82-\x15c+\xd6\xd2\x12\xd9F-iY\xb2\xc6l\xb2s\
\xbcX\x85l6\xa0\xe6pn\xce\xcc\xef|\x9c\xef\xcc(\xf7\xb6\xe7\xbd\x96\'\x14\
\x15\xff\x1f\nCJM\t\xef\xa7w\xf1\xe4\x05\t9\x84\x04\x80\'\x1f\x9f\nN<\x90\
\xc1p\xfd\x00@\x8a @\xca\xd8\x08~\xc7\xaf\xee\xae\'\xe1r\xe1\x94\xae\xeaI\r\
\x06\x80@\xbd\xb9\xb8\xe1t\xa8m\x8e\x1a\xd91\xb3\xd1\xda[\xdeZ\xfe\xe6\x7fe\
\\Y\xdcp\xfaH\x02E\x12\xfd\xa7\xdd\xb0[8|\xach\x14+o\xee?^z\xa6\xa5\xb4\xf7\
\x9b\xd5\xca\xdb\x07\xdd\xb0\x9b\x94 @\x00 \xa2\xde\xc9$I\xa6\xb0\xdaA\xad\
\xfa\xe9\xc3\xcdk7rzv\xe7`gu{M\x92t=\xb70V\x88\xd9\x00\x06\x18\x01 \x18o\xf8\
\xfb\xf6\xe9\x19sd\\\x92\xcc\x8f\xe6\xcb\x13\xd3\x00\x8c\xb4\xd1\x0f\x13\xb1\
?\x8ez\x12\x00\x14c$\xe3\xba\xbb\x8d\xd6~\xb3\xe3\x0b&6\xbf|\x0e\x82@\xe3Z\
\x12\x16\xd1\x14\xf1\x1dC0\xce\xd4T\xd9\x9a~\xf9\xce\xc9\xe7\x8e\xb8\xf5\xfa\
x.3\xefT\xac\xacu\xf6\xf8\xec\xdf_$J\xae\xf0\xab\xf6\xe5+g.\xa9\xaa:7s\xceY{\
57{\xfe\xce\xc2\xdd~\x92 (\xb1N"J\x8bt)S\x8aJ\xfb\xa8\xfd|\xeb\x85\xfcAK+\
\xaf\xa7NL\xf6\xc3\x03\x8dLML>\\\x7f\xa4\x8aCQ\xd9\xee\xb4\xbf\xd7\xf7n_\xbf\
\x95\xd5\xcd\x01\xaeA\x82\x00I\xb1\xdfY2\x8b%\xb3\x18\xc3\xec\xdf\x8f\x8dD\
\x10Hp\xce\x9aA3y\xf7\x8f\x11\x92\x14\xba\xa6\xaf\xd4Ve\x18\x0e\xd1\xcf8\xb7\
\x0c\xeb\x17}\x07"xj\xbf\x8e\xe6\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeBitmapButtonBitmap():
    return BitmapFromImage(getTreeBitmapButtonImage())

def getTreeBitmapButtonImage():
    stream = cStringIO.StringIO(getTreeBitmapButtonData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeButtonData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x12\x08\x02\
\x00\x00\x00\xd0G\xb9z\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01?IDAT8\x8d\xa5\x94\xbdJ\x03A\x14\x85\xcf\xecL0$J\xd4X\xa7\xb1\x10\xb1Ic\
\xa1\x85\x06_@\x02>\x81\x04\x9fE\xf0\t\xfc)CT\x10;\x11\x14v\x0b-L\x14\x13\
\xc1\x04C\x04\x03\x16b\xa7\x9b\x85\x985;\xc7Bm\xdc\xb8\xc8x\x98n\xce\xfd8\
\xf7\xdeaD\xab\xdb\n\x18\xc0TRHU\x7fn\xb8]W\x89\x98A\xbd\xb0\x10\x8f\xc5\x95\
\xfb\xe6\xe6&\x175\xb4Y\x8a\x93\xe6\xa9\x92\x94\xbe\xf6\xcd\xea\x01\x80B\x11\
\xd0\xda0\xc2\'C\x01 \xf8O\x04\xc3\x08\xfb\xd2\xb9{h\xa6\xd2\xa9\xfc\xc2r"\
\x96\x88\x02\x00\x16\x00\x86d_:k+\x85\x99\xa9\xe9\xd2\xf1\x9e]q\x02\x1dtz\
\xdeE\xad\x1cv~#\xc0\x1f\x07\xc0\xd6\xe1N\xe9h\x7f~v\xce\xber4\xb5\xd7\xeb\
\x94o*\x03\x9c\xa4\x1a\xd4\x07\x08\x14\xf2\xab\xb7O\xf5j\xbd& \xfa\xba\xef\
\xeb\xf7\xaf\x8b\x90~\x1d\xe7\xe6\xc1\xf6\x0b^\x97\xb2\xb9\xf4\xe8\xf8\xfa\
\xee\xc6\xc8\xc4\xb0\xa2\x1a\xe4\xa4(6\x8a\xd9L6b`\xd1:\xbb?W\x04H\xf3\xa52\
\xa2\x91\xbfC\x14\x01M\xf3\xd7IPIiy\xbeg\x8c\x08\xa8Ur(y\xfdX\xd5\x81\xc9\
\x97aI\x99\x19\xcb\x88v\xaf-\x840NA\xf2\x03x{\xcaq\xd4(\x8e\x88\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getTreeButtonBitmap():
    return BitmapFromImage(getTreeButtonImage())

def getTreeButtonImage():
    stream = cStringIO.StringIO(getTreeButtonData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeCheckBoxData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\n\x00\x00\x00\n\x08\x02\x00\
\x00\x00\x02PX\xea\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\x00\
\xc0IDAT\x18\x95cL\xdd\x9c\xce\x80\x1b\xb0000\xb4z7#\x0b\xfd\xfc\xfbs\xc7\
\xed\x9d\xfc\x1c|\xbb\xaf\xeeeBS\xfe\xe7\xdf\x9f\xcd\xd7\xb7\xbc\xf8\xf8\xf2\
\xcf\xbf\xbf\x0c\x0c\x0cL\x10!\xb8\xf4\x91GG\xde~}\xa7+\xa5\xed\xa2\xe4\xcc\
\xc0\xc0\xc0\xc4\xc8\xc8\xb8\xe5\xe6\x96\xfd\xf7\x0f000<\xfb\xf2\xec\xe6\xcb\
\xdb\x12\xfc\xe2V\xb2V\x08\xbb\x19\x18\x18n\xbd\xba\xcd\xc0\xc0\xf0\xee\xdb;\
&FF{E{\xb8aL\xff\xff\xff\xf7V\xf7\x16\xe7\x13\xbd\xf5\xea\xf6\x9b/o\x15E\x14\
\x05\xd8\xf9\x11\xd2\x0c\x0c\x0c\xacL\xac\xde\xea\xde\xbc\x1c<\x0c\x0c\x0cz\
\x12\xba\xc8.\x85\xba\x9c\x95\x895T7D]\\U\x8cK\x0cY\x9a\x11\x7f\xb0\x00\x00\
\xffq=\xe3s\x8b\xab\x0f\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeCheckBoxBitmap():
    return BitmapFromImage(getTreeCheckBoxImage())

def getTreeCheckBoxImage():
    stream = cStringIO.StringIO(getTreeCheckBoxData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeChoiceData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01AIDAT8\x8d\x95\x92\xb1J\x03Q\x10E\xef\xbe\x9d\x90@\nI\x13\x9b\xb8\
\x85\x11\xc5B\x7fA\xfb`\x99\xbf\x10lB\xc4\xc2\x1f\x10\xf1\x0f\x14\xc5\xc2B\
\x91ha\xa1\x95?\x90\xd4v\x91\x14\x9a\x80)\x96Hd\xdd\x9dk\xb1d\xd9@\xde&\x0eS\
<\xb8\xe7\xdd7wxN\xab\xfb\xe0\x8f}qr\xf8\x7f9\x06\x85\\A\xfc\x1f\x7f\xb7\xba\
\xa3P\x1b\x17\x84A^\xf2\x04g\xaa\xcfo/\xe2\xd2\r4\xc8xj\xf0=XY\xf2B\xfd\x9d-\
\xd3\x11\x02\xaa\xd6\x11\x00(\x95P;C\x01`\x1br\n\xb424\x00\x99\xd9\n\xc6\x16\
\x04#F\x87\x17G\xed\xf7N\n\x80\x01\xc0\xcc\x02\xa9\xaa\xf1\xf9\xe4\xf6\xb4u\
\xf3\xb8\x7f|\xd0\xfd\xeaNd\xcc\x0f\xc2T\x90f\xbd\xd1\xac7\xa6\xa2\x91\x02\
\xceY\x05\xc9\xc4\xe9\xee\xf5\xbe\xdf\xeb\x03\xd8\xab\xd5\xbc\x92\x17\x03&\
\xc9ik\xa4v\xb1\xbd\xb9u\xf5t\xfd\x11}VJ\x95D](\xc8\x84\xc6Z\xb9zyv^-\xaf&\
\xb7H\x08\x93Q\xadA\x94`\xc2l,\xaf#ue\xa1uNP\xeb\xbf\x10\x02\xca9\xbf3n\x9b\
\xb5\xb8\xae\x19\x05\xa3\x0c\x0b12\x1c\x0fC\rg\xaa\x11U\x8a\xf9b\xbb\xd7\xd1\
(\xcap\xb1\x95q]\xaf\xe4\xfd\x01\x89v\x0e\xe2\x88\xber\x84\x00\x00\x00\x00IE\
ND\xaeB`\x82' 

def getTreeChoiceBitmap():
    return BitmapFromImage(getTreeChoiceImage())

def getTreeChoiceImage():
    stream = cStringIO.StringIO(getTreeChoiceData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeComboBoxData():
    return \
"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\tIDAT8\x8dc\xdc\xf2h\xcb\x8b\xcf/\x99\x18\x99\x190\xc0\x8b\x0f\xcf\
\x15\x84\x141\xc5\xe1\x80\x91\x89\x81\x83\x95\x83\xe5\xd5\x97W~\x9a\xbeXU\
\xec\xb9\xb5\xc7J\xc9\x02\x8f\x11\x0c\x0c\x0c\xbbn\xeefa``\xc2%\xfd\xff?\xc3\
\x9f\x7f\x7f\xf0\x1b\xc1\xf0\x9f\x91\x05\x9f,\x03\xc3\xbf\x7f\xff\x08\x18\
\xc1\xf0\x1f\x9f\x11\x0c\x0c\x0c\xff\x19\xfeSh\xc4\x7f\x82F\xfcg` \xe4\x8a\
\xffP#\xd6\x1f\xdc\xf0\xec\xd1s\x08\xdb\xdf\xd7OF@\x1an\x04\xce\xb0\x84\xa9\
\xf8\x0fAz\xdazKv-\x9b\xb2x\xda;\xe6w\xd2\x02Rpq\x86\xff\xf8=\x82\xe4\x0f%a\
\xc5)-\x13W\xef][\x11Q\x86\xe69\x12\x82\xd3P\xce\xc00\xd1\x80\x01=\x8c)\x8e\
\x91\xff\xff\xf1\xba\xe2?Rp\xe2QC\xe3t\xf1\x9f\x81\xe1\xdf\x7f\x02\xa9\xf3?\
\xc3\x7f\x16\x06\x06\x9c\x8a\xfe\xfd\xff\xfb\xe5\xd7\x17\xfcF\xfc\xfd\xff\
\x8fE\x8cGl\xdf\x9d},LX\x9cs\xeb\xf5\xed\x0f\xdf\xdf\xe3\xd1\xcf\xc4\xcc,'(\
\x07\x00\x9cpuB\x98\x91d\x19\x00\x00\x00\x00IEND\xaeB`\x82" 

def getTreeComboBoxBitmap():
    return BitmapFromImage(getTreeComboBoxImage())

def getTreeComboBoxImage():
    stream = cStringIO.StringIO(getTreeComboBoxData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeCommentData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeCommentBitmap():
    return BitmapFromImage(getTreeCommentImage())

def getTreeCommentImage():
    stream = cStringIO.StringIO(getTreeCommentData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeDefaultData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeDefaultBitmap():
    return BitmapFromImage(getTreeDefaultImage())

def getTreeDefaultImage():
    stream = cStringIO.StringIO(getTreeDefaultData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeDefaultContainerData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01\xf6IDAT8\x8d\xdd\x94\xcbn\x131\x14\x86mg&j#\xa0\x99\xa4\x11A4\xb4U\xd5\
\xcb\x02VeCA\xb0\x83\xa7@\xec\xe1\x9d\xe0I`\x07\x12\xac\nj+PHiRP\x94\xb95\
\x93\xc9\x8c\xef\xc7,\x06Eip\x85\x92%\xff\xce>\xe7\xff\xfc\xfb"\xe3\xd7\x87o\
\x9a\xd5&ZTg\xd1\x99\xb3^_\xdfll,\x8c\x00\xa3\xc9\xc2\xe6\x89\xfe\x1b\x84c\
\x9d\xf5s\xff\xf0\xd7g\xa1E.(\x95\x94\t\xbaT^~\xb1\xff|\x8e\x14\xed\xb0}\xbf\
\xb5\xbfV\xbd\xdd\xbcqs\xf5Z}\xa5\xb2\x12\xa5Q\x7f\xdc\x9f#\x05S\x9c)\x96\
\xb0QB\x93\x84&Q\x1a\'Y"A\xce\x81\xa0\x82RI\x13\x9a\xf8i\xe0\x0f\xfd\xb2S>\
\xd8y0H\xfd8\x8f\xc1\x00\x18\xf0\x96\xbd-ok\x16\x11\xe4\xc1i\xfcC\x81\x94Z\
\xb5\x07\xdf\xbdJ\xb5\x1b\xf6\xe2\xf1\x05\x97\xec\xe1\xee\xc1\xb3\xed\xa7\
\x99\xcc\n?\x18\xf8\x1a|\xb3 \x8e\x06\xc7\xf7\x9aw\x83,\xa42\xc7\x08w\x82\
\xd30\x8d\x18gR\xfd\xc9\xaf\x8d6\xc6(P\n\x14\x18\xb0l\x84K\x0e\x0621\xceD\
\xde\xaa\xaf}\xe9\x1d1N\xef4Z\xda\x80K\\\x83\x0c\x18\x90Z2\xc5\x0c2\n\x94\
\x05\xc1\x14c\x8a\xa5|<\xcc\x87q\x16\xaf^\xaf\xcb\x8a|\xf5\xe8%B\xe8}\xef\
\x03\xd7\x9cJ\xaa@\x19d0\xc2\x0e)Y\x10a\x1a\x8eX:\x18\r.\xb2\xa1PB*9I\x8b1\
\xe6\x8a\x17+c\x84\t&n\xa9lAd<\xf7\xc7~\x98FB\t\xa9\xa5\xd6\xdau\xdc\xa2\xb4\
\xd7\xd8\xed\xc4\x1d\x82\tF\x18cR"\xa5Mo\xc3\x82\xd8in\x7f\xec|*N\x04\x00\
\x08!O\xf6\x1e\x17\xa5\xdaR\xadv\xabf\xb9\xfc"\xe3\xdb\xf3w\xd6\xffB\x82*O\
\xa55SW0\xad\x93\xfe\x89\xfdi!\x84\\\xe2\\e\x9b\xd1%\x04Fxzh\x90\x99\xe9\x9e\
4L\x97.!\xfe\xf6\xcc\xc8\xda\xe0t\xe3.S\xf4_a\xaf\xd4y\xfc\xf37\x9d\x9b=\xc9\
.\x89\xec\x97\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeDefaultContainerBitmap():
    return BitmapFromImage(getTreeDefaultContainerImage())

def getTreeDefaultContainerImage():
    stream = cStringIO.StringIO(getTreeDefaultContainerData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeDialogData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x02CIDAT8\x8d\xed\x90\xcfo\x12A\x14\xc7\xdf\x0c\xc3\x02\xbb@\x7f0\xb4\xa4\
\x16\x81\xa4\xa9\xe9A\x0f\xc6ZOM\x8c\xf1\xa4\x9el\xfcK\x8c\x7f\x8e\xde5\xd6\
\xb3\x1a\x8d\xc6_\x89&\xb5ikL\xd5\xc4]\xa1]Y\xd8\xad\xb0\xb0\xd0\xdd\x9dy\
\x1ePZ\x0b\x1a\xd2\xb3\x9f\xc3d&3\xef3\xef\xfb\xc8\x93\xf2\xd3\xd5\xb5\x07\
\xf1X<\x10\x01\x8c\x86\x1f\x06\x80\x08\x00\x88p\xe3\xdcJ$\xb1\xacN\xf1)JiJKe\
\xd2\x93>\x06\xb9\xf1\xe9\xb4\x96&\x8c&bq\x88\x90\x94\x9aR\x94(a\x94E\x19\
\x8b2$\x92\x8fef23|\x8c\x87\x10\xbe\xdc~\xc5\x80@\xb3\xd3hy\xed\xda^\xbdt\
\xa2\x08\x80\xa5\x89\xa2\xd9\xacf\'\xb2\xb6g/\x15\x16\xdc\x8ek{\xb6\xaa\xa8\
\xb6\xe7p5\xb3e~\xd8\x0f\xfd\x0b\xf9%\xd3\xfdn\xd8\xdf\x90\x00\x95(\t\xa1\
\x8b\xc5\xc5\xc2\xe4\xc9\xe9\xf4\xb4\x90\xb2\xd9q#@\xf5\xbaA\x91\xd6\x1a5\
\xbb\xe54;n\xd7\xef\xd6\x1b\xf5P\x84\x00\x10\x86\xe1Z\xe5\xfdn\xc3\x0cD Q2!\
\x05"Zm+\x9f\xcbW~T|\xe1\xbf-\xbfCDJ\xa8\xd92{\xe1\t\x10\x04$\x84X\xae\xb5\
\x1f\xee\x07a\xb0\xd9\xd9\x02\x00BH \x02r{\xfdNn<7\xe2 \x07\xd1m\x9d\x152\
\x85R\xb6xl\x85DA\x8f]\xdc\xe7\xbf\xe2\x00\xd6\xdf5\xbaM\xcfoS2\x92\xd4\x17~\
~<\x7fT\xe1\xf9\xed9>\xd7?\xbe\xde~c8\xc6\xb5\xb3W\x93\xb1\xe4\xa0\xe2\xab\
\xad\x0f\xe9\x02\x00$\xca\xde\xfa\xf0\xe3#\xbd\xaa\xef\xb4w\x97\xbb\xcb;\xce\
\x8e\xe3\xeeq\x95#\x95\xb3|6\x1e\x8d\x03\x00\x82\xecW\x1dj\x1bA\xa2\x94(\x9f\
}yny\x96\xa2\xc5\x12,\xa1*\t\xdd4J\xb9\xe2\xfd\x17\xab\x1b\xe5M\x85)\xbd7\
\xbd\xcf\x8e*\x10@\xa2\x14R\xccg\xe7\xd7?o\xd8U\xfb\xf2\xc2%5\xaaV\xeb\xd6\
\xdd\xc7\xf7\x96N\x9d?S8\xdd\xec\xbaB\n!\x85D\x1c\x1eDH\x81\x00<\xc9o]\xb9\
\xa9\xc54%\xa2\x08\x94+\x17\xaf\xff\xf1\xe6w\xd8!\n\x85)\xdb\xb5O\x00\xbf\
\xf4\xb5\xf6\xe0\x10\x0f\xf0\x85\x0f0{T\xc1\xb5LV\xe3\xff\xaa;\x04\xc2_\x82\
\x1c\xbe\x18\x1df8F7\xec\x1c\xa3\xb2G\xd9\xa9\xfc\x04t6,\xc1\xe3\x10\xe4B\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeDialogBitmap():
    return BitmapFromImage(getTreeDialogImage())

def getTreeDialogImage():
    stream = cStringIO.StringIO(getTreeDialogData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeFrameData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01uIDAT8\x8d\xed\x90\xbbN\x02Q\x10\x86g\x0e\x87\x8bK@`\x97K0\x08\x94\xf6\
\x12\xac|\n\xe3\xe3\xe9\x1b\xe8\x13h\xa5\x8d&j\xa2\x16v \xc4\xd5\x85Ea\x91\
\x85=\x97\xb10!(\xa2\xc4\xc2\xca/\xd3L\xe6\x9f/s\x0e\x1e\xb5\x8e\x0f.\x0ec\
\xd1\x98P\x02\x96#\x90\x02\x88\x00\x80\x08v7wB+\xdbF\xce\xca1\xc6\x12\xf1\
\x84\x99\xcc\x04$\n\xa9|2\x9eD\xceV\xa21\x08a\xc2HD"a\xe4\x8c\x879\x0fsBm\
\xad\x9aE\xb3h\xadZ\x12\xe4\xc9\xdd)\x07\x84\x81\xdf\x1f\x8e^;\xcf\xdd\xeaZ\
\x05\x80\xaa\xe9\x8a=x\xca\xa6\xb3\xee\xc8\xad\x977<\xdfsG\xae\x111\xdcQ\xcf\
2\xcc\x1b\xfbv"\x83\xadR\xdd\xf6\x1e\x9b\xee=!0M\x1a\x91\xd5*\xb5rf=\x9f\xcc\
+\xad\x07\xbe\x17\x02\xd6\xe86\x19\xb1N\xbf\xe3\x0e{\x03\xdf\x1b\x07\xe3n\
\xbf+\x95\x04\x00)\xe5E\xfb\xf2\xa1o\x0b%4i\xae\xb4""\xe7\xd5)\x15J\xed\x97v\
\xa0\x82\xb3\xd69\x111d\xf6\xd0~\x7f<\x02\x12\x10":\x9e3\x91\x13!\xc5\xb5\
\x7f\x03\x00\x88(\x94\xc0\xbd\xab\xfdB\xaa\xb0\xe4G\xce\xd3p\x1b\xbcl\x96\
\xab\xd9\xca\xaf\x15\x9a\x14\xfb\xf5\xf2\x94\x7f\xc5\xbf\xe2\xaf\x15BKD6\xad\
o\x14|\xd1 \xcc8\x91^\xe6\x8a\x0f\n\x04\x9cm\t\xe8Sz\x1a\x98\x1d}P\xcc\xef|\
\xe2\xcb\x00o\xf6\x9ac\xe9\xfft\xecBZ\xbd\xf6\x1b\xd7\xe0\xb4$\x91\xcb\x90:\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeFrameBitmap():
    return BitmapFromImage(getTreeFrameImage())

def getTreeFrameImage():
    stream = cStringIO.StringIO(getTreeFrameData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeGaugeData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x00\xe0IDAT8\x8d\x95\xd0\xcdN\xc3@\x0c\x04\xe0\x19\xaf\x95@\x9b^\xb8\
\xc3\x1b\xc3\x93\xf1\x08\xf0\x02\x9c\xf8Qi\xaa\xc4\x1e\x0eH\x90m\x04\xca\xfa\
\xb6\x96\xfc\xedhx\xff\xf8p\x9aF\xd4s<\x1f\x0fW\x07l\x98\xce;?M\xe3\xae\xdf-\
\xb7\xfb\xeez\xe8\xf7w7\xb7[\x88\xa7\x97g\x07\x04h\xb9\x15@Z1\xdfB\x18\xcd!d\
\xd6\x84\x04\xe9\xaf\x9b\xf5\xb8\xa0D\xd6D6\x00\x80\x03\xc8\xac\x886\x00p\
\x01\xbaHQ?7\xa5\x90V]\xa0\xa5\x0b@yA@j\xaas\x9db\x8e`K\x1d\x0e\xc0\xc8\xdf\
\xfb\x9c\xa5 J\x13A3\xfb\xf9?%\xd0 \xfe\x7fV\x11\x04\n\r\xc0\x1c\xb3\x14\x85\
\\\x86\xda2F\xd0\xe8!\x85\x924\xd2\x8c\xd6d8\x88T(\xe3;\x0b\x00\xa3\x05\xa3\
\x81\x18\xfa\xe1}\xfcX\xae^?\xdf\xce\xd3\x18\xb1I)V\xbe\x00A\xa9o\xd4\xd7<;\
\xbe\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeGaugeBitmap():
    return BitmapFromImage(getTreeGaugeImage())

def getTreeGaugeImage():
    stream = cStringIO.StringIO(getTreeGaugeData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeListBoxData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x14\x00\x00\x00\x16\x08\x02\
\x00\x00\x00O#+Q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\x00\
\xf4IDAT8\x8dc\xdc\xfex\x87(\xb7\x08\x03\xe9\xe0\xf5\xd77,\xa2\xdc"r\x02rdhf\
```b``\xf8\xf5\xf7\xd7\xe9\x9b\xa7o\xbf\xb8\x83U\xc5\xcc]\xb3qifa``\xf8\xf7\
\xff\xdf\x85\xfb\x17?|\xf9$**r\xe3\xd5\rYN\xd9_\xff\x7f\xa9\xc8)K\xf3I\x1b)\
\x1a\x8a\xf1\x8a\xe2\xb3\x99\x81\x81A\x9c_\x9c\x83\x93]\x88W\xc8U\xdbURPBAD\
\xdeU\xdb\xe5\xe5\x9bW\x0c\x0c\x0c\x17o_\xbap\xef"V\xcd\x8cg\xde\x9d!\xcf\
\xcf\x8f><b"C\x1b\x1c\x0c\xacf\xfcQ\xb5\xeb\xca\xee\xb3\x8f\xcfa\x95"\x1cU\
\xd6jV\xfb\xae\xef7\x965\xc2\xe9l<Q\xd5\xb4\xaaUEL\x05\xab\xcd\xa3Q\x85\r\
\x1c\xbey\xe4\xd8\x9d\xe3X\xa5\x08G\x15\x0f+\xcf\xfdO\xf7\xf19\x1bWT\xfd\xf9\
\xf7\xe7\xdd\xf7\xf7,\x8c\xacX5\x0f\\T\xb1\xbc\xfe\xfa\x86<\x9d\xaf\xbf\xbe\
\x01\x00\xc7\xe0\x91m\x19\xbf\xad;\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeListBoxBitmap():
    return BitmapFromImage(getTreeListBoxImage())

def getTreeListBoxImage():
    stream = cStringIO.StringIO(getTreeListBoxData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeListCtrlData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeListCtrlBitmap():
    return BitmapFromImage(getTreeListCtrlImage())

def getTreeListCtrlImage():
    stream = cStringIO.StringIO(getTreeListCtrlData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeMenuData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x16\x08\x02\
\x00\x00\x00F\xc8\x8b+\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01\xf0IDAT8\x8d\xcd\x92\xcfo\xd2`\x1c\xc6\xdf\xb7-m)\x95\x96\x02\x1d\xe0\
\xc8\x98\xae\x1b\x89&&\x8596\x0fz\xd0\xb3&\x1a=\xe9\xbf\xa8\xa7\x99839i4\xce\
\xec`\xa4\x8a\xd8\xceu8\xe8\xaf\xd1\x96\xb6\x942<@\x88K8\xa0\'\xbf\x97\xf7\
\xfd\xe6\xfd<y\xf2<y\xe1\xfe\xe9~*\x9e\x02\x8b\x8d\xe5[\x18Gq\x05\xba\xb0\
\xa0\x00B\x88Ln\xaa\xa3j\x9e6\x17\x1a\x8c\x06u\xa5>\x1a\x8f&+69\xde|\xaf+\
\x9arg\xe3v\xc7\xe9\x16\x98|\xbb\xf7+\x88\x82\x18\x12{p\xed>\x04\xf0\xc8\xfc\
\xb9y9H\xc4\x12\x00\x00d\xe6%\xe4\x84/\xa7\r\x00\x80l(\x95e\x11\x02\xc8R\x8c\
=\xb0q\x14g\xe2\xc9\x99\xe1\xd4\xa1\xb2,\x9a\x9eY-V~\x98r)\xb5\x92\xa12\x95\
\xa2Hb$\x8d\xd3n\xe8\x86\xd1P\xd2\xbfV\xf2"\x00\x00\x1e\xda\x87\x8b\x87n\xbb\
mdAt6\xff*hY\xad\x13\xe7d.\x11D\xc1^\xeb\xf5\xecu\x1a\xfa\xad\xf2N\xd6\x94[k\
;z_\xcf\xd2Y\xdd\xd5\xfba?\x86\xc6\x1e]\x7f\x88"h\xad\xb8\xf5\xfc\xf3\x8bg\
\xe2S\xf0g\xad\xeb9\xa1\xd9mb\x08\xd6u\xba\x9b\xc5*\x8e\xe2Y:\xe3\x84\x0e\
\x04pWzyo\xfd\xee\x05\x87\x9d\xd2\xb6\xe1\x99K4\xffMo^\xe5\xae\xf0\t~\xbbT#P\
"I$\x83( q\xb2\xe3v\xf2t\x1e\xfc\xcf\xb56\xf4\x86|&\xcf%\x82(x\xd5\xda\x93\
\x0ci\xb2NC\x7f<>\x905\xe5\xe6j\xd5\xf2\xceX\x8a\xe9\xf9v\xcf\xb7\t\x0c\x7fr\
\xe31\x89\x91i*}p\xfc\xa9\x9c.\x83\x0b\xbfuiM1\x8e0\x14\xb3\x03\xa7\xb6\xb2u\
\x89\xa4\xf3L\xce\r\xddp\x14\x963\x1b\xd1y4%\'-\xa9\x8ejz&O\xf3\x92&\ti\x81\
\x8bs\x86o\xe0(\xce\x12\xec\xf0|\xf8^\xfd \x16D\x96`\xdan\xfb\xafk\xc5L\xcf\
\x1c\x8f\xc7\x0b\n,\xdf\xfa\r\xb7k\xdc.\xc5\x86\xd0\xc7\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getTreeMenuBitmap():
    return BitmapFromImage(getTreeMenuImage())

def getTreeMenuImage():
    stream = cStringIO.StringIO(getTreeMenuData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeMenuBarData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\n\x08\x02\
\x00\x00\x00?\xc29\x8c\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01LIDAT(\x91\xa5\x91MK\x02Q\x18\x85\xef\xbds-GJ\xc7[)\x8c\xf8\x01Z\xb9\xb0\
P\xa2M\x10\x14\xad\xa2\xaf\x9fX\xbb\xd0 $\x88\xcaM)Ee\x06)\xb6\x88\xa6IH\rI\
\x18\xcb\x99\xab#5o\x8b6\x81\xcb9\xeb\x87\x87\xc398\xd7\xc8!{\xc1\xcf=\xc5\
\xa6\x82\x02\xb2\xec*,\xb0.J\x05\xedK\x9b`L\x9e\x94E\x87\x18\xf0\xcb\xff\tM\
\xd7\x8e\xcfO$&\xad-\xae\x8a#\xe2KC%\x98\x08T\x18|\x0fbr\x14!D\x00@\xa9+;+[\
\x02\x11\xd4\xa6\xda\xfch\x1e\xdee\xd3W\x07\x86i\x00\x00\x00t\xf8\xa7\x9f\
\xf96\x96\xd6\x05"\xec_\xa6\xd3\xf9L\xed\xbdv]\xbe\xd9\xcd\xec\xe9\\\x07\x00\
\n\x08x\x9fg\x0bG\x1a\xd7\xfc\x1e_\xc7\xe8\x94\x8a\xf7\xa1`\xb0\xd5nE\xe4\
\x08B\x08\x00n\x1f\x8b&6c\xa1\xa8\x07y\x92\xd1$7\xb9\xd39\x9a\x8a\xa7\\\xa2\
\x0b\x10\x10\x00\xf0\xba\xa5\xed\xe5\xcd\x80W\xa6\xd4!\x8dI\xf1\xf9\x19\xdf\
\x94\x8f1\xf6\xd7\x82`L\t\xb5~\x80\xb9\xd9\x9bQ\x7fP\xcb\x94:\xc6\x9dn\xb5\
\xfd\xaa\xf7\x0c\x00\xc0U\xbdz\x9a?\xe3\xfd\xdeB"\x15\x0e\x84\x87\xd7RjJ\xe5\
\xa9\x8a\x10\x9a\x8e\xc4\xe6f\x13\xc3\x00\xaet+v\x1f\xe9\x9a]\x9b\x8a_\xdf\
\x9a\x9bUwSK\x9b\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeMenuBarBitmap():
    return BitmapFromImage(getTreeMenuBarImage())

def getTreeMenuBarImage():
    stream = cStringIO.StringIO(getTreeMenuBarData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeMenuItemData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x08\x08\x02\
\x00\x00\x00\x7f\x14\xe8\xc0\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\
\x00\x00\x00\xd0IDAT\x18\x95\x8d\x8f\xcb\x0e\xc1P\x10\x86g\xaam\xa8FU\xba\
\xa0\x08\x1b\xb1\xb0\xeba\xcd\x1b\xf0\xc4\xf4\x11\xac\\\x12\xa1D\xeaRN\xa3mz\
AS\x8b\x8a\x95Eg3\xf3\'\xff\x97/\x83\xd3\xf3T.\xc8\x90m\xec\xc0f+BE\x15\xd5\
\x8c\x00"2\xe9ut\x8f\x96o\xfd-Eq\xa4\x1bz\x9c\xc4id\xd35\xdb\xe8\x86e\x8c\
\xba\xc3\x8b{U\xa5\x9a\xf98\x85\xef\x90c\xb8Io\x8c\x80{z\x18\xd4\xc3"W\x04\
\x00\xe6\xe7\xeaT;\x8b\xf3\x12\x00vw\x8344\x04,\x0b\x92\x139|\x8e\x97\n\xa5\
\x9f\xf0k \r\x8d\xfa\xb4\xdf$[\xbak\xcb-EPHS\xcb\xb3y\x91\x17\xbd\xa7\xf7|\
\xbfV\xb75\xa9i\x00\x80sg\x9e\xfdi\xd33Y\xea\xd3$I2\x02v`\x7f\x00\\\x03OE|u\
\xf3\xf3\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeMenuItemBitmap():
    return BitmapFromImage(getTreeMenuItemImage())

def getTreeMenuItemImage():
    stream = cStringIO.StringIO(getTreeMenuItemData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeNotebookData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01EIDAT8\x8d\xed\x92\xcdJ\xc3@\x14\x85o\x92\xc9\xcf\xb4\x12\r\x04\x91\xee\
\xa4n\xacU\xec\x03\xe8\xa6\x8f \xee\xc57\x12_A\xdc\t-.|\x01\xeb\xcf\xc6M\xb2\
\xb1`-\xed\xa2J\xc0F\t\xdaN;\xb9.\xa21\x19\x13\x91\xae{vs\x98\xfb\xcd9\x97\
\x91\x8e\xee\x8e\xfb\xc3>\xa4\xa5)\xdanyG\'\xba\xe0[\x85%S7\x05Sjt\x9a\x1b+\
\x15\xc1\xe5\xc8[\xdd\xab5\xbb\x9c4\x11\xc0\x0b\xbc\xca\xf2:Ui\xd2\'T\xa5\
\x86j\x08\x88\x10C\x83\x18\xb2,\x0b>U)\xe3L@\xc8\x00\x18\xcb}t\xd9\x94!b\x88\
\x08\xff\x96\x8c\x00\x08\x88\x80\x8c\xb3\xa6s\xfe\xe0u\x10\x10\xe0\x07qrqzv\
\xddx\xf2\x9fs\x11\xf0\x1d\xe3\xa6}k\x1b\xf6\xa5\xd3\x8a\x8e\xa9^SN\x14\x92\
\x87 \xf1\x83\x8b\xa6yX?p\xba.\x00$\x83\xe8\x9aN)\x85\xfcf\x04\xbf\x06\xa0Z\
\xaa\x02\xc0\xd6\xeaf\xd4+\xbe\xb1_\xdf\xcb\xdfC\x94\x02\x01\x7f-Ol\xf27\x02\
s"\x8e&#\xff\xe3U0\x83q\xf0\xf2>d|\x92N\x91%ERj\xa5\xed\x0c\xfa\x82h\xdc{m"\
\x81\x94I\xb1\nVv\xee\xb4\x8aZQ\xfc\x7f3h\x8e\x98#\xb2Dz~\x8f\xf1\xf1\xcc\
\xf3\x83\xb7\xc1\'=[\x90\xec\x8bh\x9f\xd9\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeNotebookBitmap():
    return BitmapFromImage(getTreeNotebookImage())

def getTreeNotebookImage():
    stream = cStringIO.StringIO(getTreeNotebookData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreePanelData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x00oIDAT8\x8dc\x9cwa\xbe\x84\x80\x04\x03\xb9\xe0\xc1\xdb\x07,\xf2\xc2\xf2\
\x8a\xa2\nd\x1b\xf1\xef\xff_&\xb25\xc3\xc1\xa8\x11\xa3F\x8c\x1a1\xa4\x8d\xf8\
\xfd\xef\x0f##\x13\x1c\xe11\x82\x05\x97\x04+\x13\xcb\xff\xff\xff\x88q\x05\
\x8a\x11\x8c\x0c\x8c\xc8\xdc\xff\x0c\xff\xd1T\xc3\x15 K\xa1\x18\x81\xa9\x07\
\r`U\xc0\xf2\xf0\xdd\xc3\x1f\x7f\xbe\x13r,N\xf0\xf8\xdd\x13\x00\xb2.\x1f)\
\xa2e \xa4\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreePanelBitmap():
    return BitmapFromImage(getTreePanelImage())

def getTreePanelImage():
    stream = cStringIO.StringIO(getTreePanelData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeRadioBoxData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeRadioBoxBitmap():
    return BitmapFromImage(getTreeRadioBoxImage())

def getTreeRadioBoxImage():
    stream = cStringIO.StringIO(getTreeRadioBoxData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeRadioButtonData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x90\x91h6\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01\xc3IDAT(\x91\x95RKk\x13a\x14=w2c#\xb5S\x9c\x14b\xb4\x93\x91\xd8\xc6P_\
\x041\x8d\x0c\xbaH\xfc\r\n\xba\xf1\xf1\xcf\xbaS\xc4\x95\x8f\x95.\xd4\x01\x1b\
\x04\x93\x85I+8:I1\xa9$\x11\xbf@\xcc\xa4\x9d\xb9.\xbe\x90G\xc9\xa6g\xf1\xf1\
\x1d8\x87{8\xf7\x92;pq\x1c\xa8\xd3\x84\xc1~\xe0\x07a\x00\x80\x88TE\x8d\x90\
\x1a!e\xbea\x18\x0e\xfb\x07\xfd\xf2\xaf\x8a\xdb\xfe\xd1\xe9u\x08\x14[2\xd2\
\xf1\xf5\xdcjNS\xb4\xb1\x8cd$?\xf0\xdb\xfd\xf6\xab\xafo\x96O\xea\xb7/\xdc\
\xb2\x96-\x00\xde_\xef\xfd\xf7\x0fb \xeee\xef\xea\'\xf4\x89\x81\xc1\xc2\x17\
\xcf+/.\x9f\xbdTL\x15\x8e\x84~\xeb\xbe\xab6\xab\x8fn<\x9cD\xf2\x03\xbf\xfa\
\xbb\x16;e\x14S\x85\xc3\xf0\xd0\xa9;?\xbb\x1e\x80\xf3\x86e\'\xedb\xaa\xd0\
\x14\xcdr\xab\x9cMd\x99Y\x01\x10\x84A\xad\xb5\x93\xb76\x018ug-\xb6vg\xbd88\
\xf0w\xf6\xbf9u\x07@\xde\xda,\xefU\x08\x04`\xd4@\xb7\xd75u\x13\x80\xd7\xadO\
\xe7\x91\xd4\xd4\xcd\xe6\x9f\x16\x11\x8d"\xc9\xdf\x18/\xab\xaf\xe7n`2AU\xd4\
\xd8\x92\xd1\x10\r\x00\x96\x91\x9c\x16I\xda\x10\x8d\xc4\xe9\x04\x83G\x86\x08\
\xa9W\xcf]\xf9\xe4m\x03\xb0\x93v&\x9e\x8ej\x0bQm!\x13O\xdbI\x1b\xc0\xb6W\xca\
\xae^c\xe6\xc9\x1e\x02\x0e\xb7>om$6\xe6\xd6Zk\xd5\x9e\xe4\x1e\x8f.`|Kb(\x9e~\
y\xa6Gg\x17\xe7~\xec\xfd\x13\x0f\xae\xdf_\xd4\x16C\x0eg\x0crNi\xaf\xb4\xbb\
\xbf\xdb\x16\x1d\x00+\xfaJ\xe6\xcc\xc5\x9bf\x9e@R}\xd4 \x1b#\xf9\x00\x00\x98\
y,\x95\x98\xb9V\xa9`\xc8>\xe6\xe3?m,\xd4\xa6J\xde\xdcP\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getTreeRadioButtonBitmap():
    return BitmapFromImage(getTreeRadioButtonImage())

def getTreeRadioButtonImage():
    stream = cStringIO.StringIO(getTreeRadioButtonData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeRootData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeRootBitmap():
    return BitmapFromImage(getTreeRootImage())

def getTreeRootImage():
    stream = cStringIO.StringIO(getTreeRootData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeScrollBarData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x08\x08\x02\
\x00\x00\x00r\n\x98\x87\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01ZIDAT(\x91]QMkSQ\x14\x9c\xfb\xde5%\x82\x89\xe0"\xa5\xad\xa0"\xe8BP\xd7V\
\xa4\xbf@h\xffA\xa1\x7f\xa4?*\xae\x15]D\xe9J\xddi\xa3MSDI\xd2\xd8\x8f\xfb\
\xde\xbd\xf7\xcc\xb8xE\xd2\xcc\xea0sf\xce\xe1\x1c\xd7\x1f\xf5O\xe6\xbfn\xfa6\
\x160\xfe{r\xf7\xf6\x06\xaectz\xbc\xd1\xbdF\x86|\xb9\xda\xe9\xf9\xc9\xe5d\
\xeb\xe1+\x87bQ;\x18\x1dl>x\xb1\x14\xf1\xfe\xf0\xc3\x12I\xf1\xed\xe1\xbb\x02\
t\xd1bm\xd5\xac\x9a\x1d\xcd\x7f\xd6V\xd5V\t\xa28\x9c\x0e\xbfM\xbe\x03\x18N\
\x87\x14\x05\x99\xccd\xfdOoF\xb3c\x93\t\xf2\xce\x17\x04Mv\x1e\xcf\x07G\x83*\
\xd5M\x93$\xa3EK\xd1jI\xd1\x92\xd1$\x91$\xf9\xe5\xf3\xd7\xdd\xfd\xbd\xf1\xe9\
\x98$E\x0f\x81"E\xe7\x9c\x83\xa3\x08\x80\xe0U!\tjv\xfeOJ\x02\xd4\xb8\x00\xf8\
FX\xf1+\xcf\xd7\x9f\x91\xbar\x92\x89\xa9,J\x93e\xe6\xb2(\x13S3\x13\xc0\xe3\'\
\x8fv^o\xf7n\xf5\x9a\x14\x9f\x99C\n\xce9\x00\xad\xf2F\x95+\x00\x89)\xe4\xd0m\
w\x00\xcc\xeby\xb7\xdd\t9$\xa6`\x01\xc0\xcb\xa7\x9b\x00\x82\x05I\x91\xd1\xaf\
u\xd6\x06?>\xb6|k\xf1\xd4\xd3\x8bY\xb4\xb8\xf4\x91\xdfg\x7f2\xf3"S\xe5\xfa\
\xfe\x9d{\xff\x00\xcb3\x12/I\xb9@-\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeScrollBarBitmap():
    return BitmapFromImage(getTreeScrollBarImage())

def getTreeScrollBarImage():
    stream = cStringIO.StringIO(getTreeScrollBarData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSeparatorData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x02\x08\x02\
\x00\x00\x00\xd3\x91\xbb\xe1\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\
\x00\x00\x00\x16IDAT\x08\x99c\\{\x7f-\x03e\x80\xf1\xc5\xdf\x17\x14\x1a\x01\
\x00\xdc\xcf\x05\t$\xbc\x9b\x82\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSeparatorBitmap():
    return BitmapFromImage(getTreeSeparatorImage())

def getTreeSeparatorImage():
    stream = cStringIO.StringIO(getTreeSeparatorData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSizerFlexGridData():
    return \
"\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\x00CIDAT8\x8dcddbf\xf8o\xf5\xf7?\x03\x99\x80\x05\xc6`<\xc6\xcc\x88,\xf1\
\xdf\xea\xef\x7ft1t\xf0\xdf\xea\xef\x7f&rm\x86\x81\x817\x80q4\x10G\r\xa0\x86\
\x01\x14'$FF&f\x8a\\\x00\x00)\x9b\x19\xd8\x83\xb1\x93\x9b\x00\x00\x00\x00IEN\
D\xaeB`\x82" 

def getTreeSizerFlexGridBitmap():
    return BitmapFromImage(getTreeSizerFlexGridImage())

def getTreeSizerFlexGridImage():
    stream = cStringIO.StringIO(getTreeSizerFlexGridData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSizerGridData():
    return \
'\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\x00=IDAT8\x8dcddbf\xf8o\xf5\xf7?\x03\x99\x80\x05\xc6`<\xc6\xcc\x88M\xc1\
\x7f\xab\xbf\xff\xf1\xc91\x91k3\x0c\x8c\x1a\xc0\xc0\xc08\x1a\x8d\xc3\xc1\x00\
\x8a\xa3\x91\x91\x91\x89\x99"\x17\x00\x004\xc9\x19\xd8\x02\x99\x8c\xe2\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSizerGridBitmap():
    return BitmapFromImage(getTreeSizerGridImage())

def getTreeSizerGridImage():
    stream = cStringIO.StringIO(getTreeSizerGridData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSizerGridBagData():
    return \
'\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\x00JIDAT8\x8dcddbf\xf8o\xf5\xf7?\x03\x99\x80\x05\xc6`<\xc6\xccH\xaa\xe6\
\xffV\x7f\xff3\x91k3\x0c\x0c\xbc\x01\xf00 7 q\x06\xe2\x7f\xab\xbf\xff\t\x05\
\xec0\t\xc4Q\x03\x18\x18\x18)\xcd\x8d\x8c\x8cL\xcc\x14\xb9\x00\x00D\xbf\x15\
\xd5\xf1+\xb0\x81\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSizerGridBagBitmap():
    return BitmapFromImage(getTreeSizerGridBagImage())

def getTreeSizerGridBagImage():
    stream = cStringIO.StringIO(getTreeSizerGridBagData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSizerHData():
    return \
'\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\x00DIDAT8\x8dcddbf\xa0\x040Q\xa4\x9b\x1a\x06\xb00000\xfc\xb7\xfa\xfb\
\x9f"\x03\x18\x18\x18\x18\x18\x8f13bS\xf0\xdf\xea\xef\x7f|r\x03\x1f\x06\xa3\
\x06P\xc1\x00FF&f\x8a\x12\x12\xe3\xd0\xcfL\x00$g\x0e\x9e;\xba\xd4\xfb\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSizerHBitmap():
    return BitmapFromImage(getTreeSizerHImage())

def getTreeSizerHImage():
    stream = cStringIO.StringIO(getTreeSizerHData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSizerVData():
    return \
'\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\x00?IDAT8\x8dcddbf@\x06\xff\xad\xfe\xfeg \x00\x18\x8f13\xc2\xd8,\x84\
\x14\xa0\x03t\x0b\x98\x08\xd9F\x08\x8c\x1a\x80#\x16\x88\x89J\xbc\x06\x8cF#\
\x9d\r\xa08\x1a\x19\xd1\xb33\xa9\x00\x00\xa4^\x12\x9d\xe4L\x11\xcc\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getTreeSizerVBitmap():
    return BitmapFromImage(getTreeSizerVImage())

def getTreeSizerVImage():
    stream = cStringIO.StringIO(getTreeSizerVData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSliderData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x08\x08\x02\
\x00\x00\x00r\n\x98\x87\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01YIDAT(\x91}QMO\xdb@\x14\x9c\xfd\xb2c\x1f\xec\xa2\x04\n\x078T@\xd3\x0b\
\x12\x88\x1c\xf9\x13\xf4/W=\x06!\xb8\x81rhL\x84"\x11\xa2\xd0\xd8\xeb\xdd}o98\
\xa4\x95*uN\xa3\xd1\x9by\xefi\xc4\xc4N\xf0\x81_\xcb\xe9\xfcm\x8e\xff\xc2(s\
\xbaw\x92\xe9l\xab\xe8-\x9b\xadfk\xbf\x1e\x1d].\x9a\xc5No\xe7_\xf3\xa2Y\x0c\
\xf2A\xed\xeb\xf1\xd3xt82\xd2l"\xc6\xd5M\xc7\xa6\xcb\xe9\xf7\xb3k%\x95\x91F\
\n\t\xc0\x91\x0b\x1c\x8a\xb4\xa8}\x9d\xa8DIe\x94)Uidr;\xbb\xcdL\xbe\x89\xf81\
\xf9\xb9_\xee\x01xk\x7f\x0b!82Er\xec\x01D\x00B\xb4\xe4"\xe0\xd8\x07\x0e\x1c\
\x19\x00"jj\x18\x11@\xf5Z\xe9\x9eN\x8a\xac\x00\xe0\xc9\x13\x13\x00\x8e\xec\
\xa8\x05\x90\xaa\xd43q$)DKm\xe0\xb0\x19\x00k\xa9\x8d\xd4\x00\xa4\x90\xfa\xea\
\xcbUw\x0f\x07v\xe4\x94T\x14\xd9\x93\x07@L6X\x99JO\x9e#\x07&\x8a\x9b\x1deZt\
\x8f\x9c\x1d|\xd2\xdf\xf6\x87]D\x99\x17w\xcf\xf7\'\x83c\xebm+\x00 7y\x8cqeWF\
\x99\xda\xd7\x8d\xb7kW7\xa1\xb1d/v\xcfS\x95vF\xf1w\xa9\x0f/\x8f\xd5\xb2\n\
\x1c\xb4\xfc\xd3\xd4\x16\x9d\x9e\xa8d\xf8\xf9k?\xebo\xf5w\x1b\xc8\xbb\xe0\
\xcez\xb4\xcc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSliderBitmap():
    return BitmapFromImage(getTreeSliderImage())

def getTreeSliderImage():
    stream = cStringIO.StringIO(getTreeSliderData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSpacerData():
    return \
'\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\x004IDAT8\x8dc`dbf`\xb0a\xf8O6\xcd\xc8\xc4\xcc@\t`b```\xf8o\xf5\xf7?9\
\x9a\xff[\xfd\x1du\xc1\xa8\x0b\x86\xa5\x0b\xc8\xa1)v\x01\x00A\xf0JsM\xdf\xbd\
i\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSpacerBitmap():
    return BitmapFromImage(getTreeSpacerImage())

def getTreeSpacerImage():
    stream = cStringIO.StringIO(getTreeSpacerData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSpinButtonData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x08\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\xa4\xe8\xa9*\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x00\xf5IDAT\x18\x95]\x90MJ\x03Q\x10\x84\xbfyy\x13\x13\x98\x18\x15\xc1l&\
\x84x\x04\x11\xc4]\xc0S\x84\x80x\x17=\x80\xe4\x00"\x88wP\x047\x1e".\xb2\x8d\
\tf\x95\x9f\xc5\x88\xaf\xcb\xc5\x0bq\xb4v\xd5]TUwr\xfdv\xd3=<\xa6\x8cD\xf5j\
\xdd\xe7\xfb\xf9y\xf7\xac<7\xb3\xa7\xf7g/\xf8\xb6\x00\xda.$!<\xc8d\xa6p\xf7r\
\x0f\\]\\&$B>j\x1e^\x1fo\x87C \xad\xa4\x83^\x1f\xf0\x80\xd0\xa0\xd7\x8f<\xd2\
h\x85\xa2\xeb6\x03\t\xf9((/"\xbc\xd0\xc7bj\n\x7f\x0e\x89\xe1\xad\xc6\xd1?\
\xab\xd1l\xb4\t\x9f,&\xcbb\x054v\xb2\xd6n\x0bp1\xbcYkN\x97\xb3\xcf\xf5\xbc\
\xbd\xd7v\xb8\x8d\x95P-\xad\x9d\xe6\'Y5\x0b\nA\x01\xe1\x85L&\x94V\xd2"\x14\
\xbfuM\xb6\xfeZ\x1bV\xfe\x95a~<\x1f\xaf\x8ae\xa9j\xe2\x9c\xeb\x1ct~\x00<t\
\x87\xefA\xf0\xe9v\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSpinButtonBitmap():
    return BitmapFromImage(getTreeSpinButtonImage())

def getTreeSpinButtonImage():
    stream = cStringIO.StringIO(getTreeSpinButtonData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSpinCtrlData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x7fIDAT8\x8d\x95\x92AK\x02Q\x14\x85\xef<\x9fcdf\x86E\x0b\x19\x85\
\x8cH\\VD\xfe\x86\\\x89\x84?!hY\x19\xb4\x8eV\xd1\x0fh\xd5B\xdc\x06n\x8a\x12\
\\\xb4\x8a"\xa1E\x85\xa4Xd)\n9\x83\x8d\xce\xcc\xbb-\xb4I]\xcc8\x87\xb7:p>\
\xce\xbd\xefr\x99r\xe6S\xfc"\x9c\r\xcc\xf4\xdex\x0bz\x17\xfa\x1d\x8e\x00OyZ\
\x95\xaa\xd1\xa5\r\xd3<\x00d_\xb2\x91\xf9\x88\x86Z\xbfy\xf1|I\x01\xc8(\xf9\
\xae4\xd4T\xa6\x0e\x14Ab!\x0f\x00\x88\xc8\x18\xbb+\xdd\xef\x9c&\x15\xa62\xc6\
\x00\x90ZE\x94\x1a\xa5\xad\x83\xedz\xa5\xee\x9e\x98\xdc\x8f\xef\xfd#\x18\xb2\
T.\xcd\xf3||=fL\x11\xa6\x85\x9b\xb3\\\x8f\x08\x88\xfa"R\xb9\xb4_\x10\x80\xc2\
\xd5\xd3\xb5Q\x0b\xc0a\xe9\x88\xfcc~EX^[\\}\xb8\xcd\x9b \x06\x1f\xe0\xdf \
\xaeqW\xb3\xdd\x14\xdb\x92{\xc6m\x80\x10e\xb1\xde\xaa\x0f\x99=D"\xbay|~"\xb7\
\xe5dl\xd7\x00\xe1r\xb8x\xca\xf7;\x85Z\xa1\x87\x08z\x83G\x89C\x83\xb0>\x88\
\xd8\x11?\xbe+\x00\xe0\xa0\x0e\xbfG@\xb4rW\x00\x80\x88N\xbb\xf3Gi\x15\x1b\
\xc5\x80\'@8\x82\xfa \x16(\x80\xe1\xb9ph6d#\xa4\xa3u,\x9f\x16\x03\xc6\x90\
\x01\x00G8Y\x95\xbbD\n\xc0FG\xc8\x8a,)R\xbf\xa3\xa1\xc6e\xca\x19I\x96(1\xafS\
\xa8\xbd\x8e\xd9\x07\xbe\x83\xd8l\xbe)\xdf/1\xf2\xbcI}kXC\x00\x00\x00\x00IEN\
D\xaeB`\x82' 

def getTreeSpinCtrlBitmap():
    return BitmapFromImage(getTreeSpinCtrlImage())

def getTreeSpinCtrlImage():
    stream = cStringIO.StringIO(getTreeSpinCtrlData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeSplitterWindowData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01\xf6IDAT8\x8d\xdd\x94\xcbn\x131\x14\x86mg&j#\xa0\x99\xa4\x11A4\xb4U\xd5\
\xcb\x02VeCA\xb0\x83\xa7@\xec\xe1\x9d\xe0I`\x07\x12\xac\nj+PHiRP\x94\xb95\
\x93\xc9\x8c\xef\xc7,\x06Eip\x85\x92%\xff\xce>\xe7\xff\xfc\xfb"\xe3\xd7\x87o\
\x9a\xd5&ZTg\xd1\x99\xb3^_\xdfll,\x8c\x00\xa3\xc9\xc2\xe6\x89\xfe\x1b\x84c\
\x9d\xf5s\xff\xf0\xd7g\xa1E.(\x95\x94\t\xbaT^~\xb1\xff|\x8e\x14\xed\xb0}\xbf\
\xb5\xbfV\xbd\xdd\xbcqs\xf5Z}\xa5\xb2\x12\xa5Q\x7f\xdc\x9f#\x05S\x9c)\x96\
\xb0QB\x93\x84&Q\x1a\'Y"A\xce\x81\xa0\x82RI\x13\x9a\xf8i\xe0\x0f\xfd\xb2S>\
\xd8y0H\xfd8\x8f\xc1\x00\x18\xf0\x96\xbd-ok\x16\x11\xe4\xc1i\xfcC\x81\x94Z\
\xb5\x07\xdf\xbdJ\xb5\x1b\xf6\xe2\xf1\x05\x97\xec\xe1\xee\xc1\xb3\xed\xa7\
\x99\xcc\n?\x18\xf8\x1a|\xb3 \x8e\x06\xc7\xf7\x9aw\x83,\xa42\xc7\x08w\x82\
\xd30\x8d\x18gR\xfd\xc9\xaf\x8d6\xc6(P\n\x14\x18\xb0l\x84K\x0e\x0621\xceD\
\xde\xaa\xaf}\xe9\x1d1N\xef4Z\xda\x80K\\\x83\x0c\x18\x90Z2\xc5\x0c2\n\x94\
\x05\xc1\x14c\x8a\xa5|<\xcc\x87q\x16\xaf^\xaf\xcb\x8a|\xf5\xe8%B\xe8}\xef\
\x03\xd7\x9cJ\xaa@\x19d0\xc2\x0e)Y\x10a\x1a\x8eX:\x18\r.\xb2\xa1PB*9I\x8b1\
\xe6\x8a\x17+c\x84\t&n\xa9lAd<\xf7\xc7~\x98FB\t\xa9\xa5\xd6\xdau\xdc\xa2\xb4\
\xd7\xd8\xed\xc4\x1d\x82\tF\x18cR"\xa5Mo\xc3\x82\xd8in\x7f\xec|*N\x04\x00\
\x08!O\xf6\x1e\x17\xa5\xdaR\xadv\xabf\xb9\xfc"\xe3\xdb\xf3w\xd6\xffB\x82*O\
\xa55SW0\xad\x93\xfe\x89\xfdi!\x84\\\xe2\\e\x9b\xd1%\x04Fxzh\x90\x99\xe9\x9e\
4L\x97.!\xfe\xf6\xcc\xc8\xda\xe0t\xe3.S\xf4_a\xaf\xd4y\xfc\xf37\x9d\x9b=\xc9\
.\x89\xec\x97\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeSplitterWindowBitmap():
    return BitmapFromImage(getTreeSplitterWindowImage())

def getTreeSplitterWindowImage():
    stream = cStringIO.StringIO(getTreeSplitterWindowData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeStaticBitmapData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x0e\x00\x00\x00\x12\x08\x02\
\x00\x00\x00\xe4>xf\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\x02\
eIDAT(\x91M\x92\xb9kTa\x14\xc5\xcf\xbd\xdf\xf7\xde\xc4qf"\x13g\xc45fqCEQ\x14\
T\x10w\xe2\x06*"h\xa1 \x16\x16b\'\xd8\x89\x7f\x86`a!\xe2R\xba\x82\xe2\x82\
\xda\xc4\rA\x0bu&\x85\xa2&fQ2#yy\xef\xbb\xf7Z$HN\xfd;\x07\x0e\xfc\xa8/\xe93\
\x18\x0053\x98\x99bJ\x88\x98@L\x04\xc0Opb\x1a4\xbb\xfe\xeef3i&Y\x12\xb9(\xf6\
\xb1\xa8\xec[\xb1gni.\xe0\x00\xf8\tn\xa0\xd9\x7f\xb5\xf7\xda\xc1\xd5\x07\xaa\
\x85\n\x00Q\t\x1a\x92\x90\xdc\xf9p\xafc\xe6\xc2\x1d\x8b\xb6;\xf2\xacfI\x18\
\xbb\xda{\xed\xd4\xc6\x93sJ\xb3c\x17G\x1cE.\xf2\xecs>\xb7\x7f\xe5\xde\xfe\
\xd1\x81\xd7\xdf\xdf\xa8\t\xab\xc9\x8dw\xb7\x0e\xaf9\x94\xf3\xb9\x88\xa3\x9c\
k\x89]\xec\xc89vL\xcc\xc4[\xba7\xbf\xf8\xfc\xd2`\x0c \xc9\x92\xf2\xb42\x81\
\x98\xd8\xb3crD4\xf5\\[\xb1\xed\xf3\xd0\x17\x06\x10$\xa8\xa9\x9a\x8aI#m\x04\
\xcd\xd4\xd4\xfe\x07\xd6U\xe9\xac\r\xd5\x18\x80g\'&A\xc3\xe8\xf8\xe8\x93\xda\
\xd3?\xc9\x1fQ\xa9\x8f\xd4\xfb\x1b\xfd\x93\x1d\xd8xH\xbd\xc1\xd4LT\x00\x98\
\x99\x98<\xab?/O\x9f\xd1H\x9a\xd5b\xb5\xd4R\x12\xd3\xc1\xc6PG\xdbB\x06`\xb0L\
\xb3L2\x83\x15r\x85\xc5\xd5n".\xb6\x14\xab\x85J\xd0 *_\x87\xbf\xae\x98\xb5\
\x9c\t\xb4k\xd9\xceG\x9f\x1eg\x92\xa5\x92\xe6\xe3|9_\xee*w\xb6\xf8\x1c\x80\
\xa0\xf2{l\xa45_\xf2\xec\x99\xc9u\x96;DCm\xb8\x9e\x86T4\xa4!\xcd4\x0b*\x99\
\x844\x8c?\xfa\xf8\xe4\xd8\x9a\xa3L\x8e\x010\xb9\x13\xeb\x8e\x7f\x19\xa8\xbd\
\xf9\xf66\x93\x90J\x96J\x164\x0c\xfe\x1d\xbc\xfd\xfe\xee\xc9M\'"\x17\x11\x88\
\xeaI]\xcd\xd4DM/\xdc\xbe\x18\xf9h\xf7\xaa\x9eB\\\xb8\xff\xe1\xc1\xf3\xd7/\
\xaf\x9c\xbd\\\xca\x95\x98\x1c\x81<\x00&\x02\x9c\xc1\xda\xab\xed\xedm\x0bz\
\xfb^\x19\xac{V\x97\xad\xb5b\\\x9c\xe0\x98\xc8\x13hB.&7\xbf<o<\xa4\xdb\x96n\
\xf5\xec\x83\x86\xa1\xe6\xb0c\xef\x88\x01L\xae\x12\x88\tjX\xbf`\xdd\xe9Kg\
\x96v-n\xcd\xb7\xfe\x18\xfe\xb9k\xd5\x8e\xff\x1c\x00\x9eT\x18\xc4D\x95|\xe5\
\xfc\x91s\xbfF\x06\x1f<{\xb8q\xd9\x86\x9e%=SM\xf8\x07b\x08J\xca\xa1\x02\xc5O\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeStaticBitmapBitmap():
    return BitmapFromImage(getTreeStaticBitmapImage())

def getTreeStaticBitmapImage():
    stream = cStringIO.StringIO(getTreeStaticBitmapData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeStaticBoxData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeStaticBoxBitmap():
    return BitmapFromImage(getTreeStaticBoxImage())

def getTreeStaticBoxImage():
    stream = cStringIO.StringIO(getTreeStaticBoxData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeStaticBoxSizerHData():
    return \
'\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\x00\\IDAT8\x8dcddbf\xa0\x040\xa1\x0b\xfc\xb7\xfa\xfb\x9fl\x03\xfe[\xfd\
\xfd\xcfx\x8c\x99\x91\x14CX\x905\xa2\xbb\x80(\x83\x18\x99\x98\x19\x18l\x18\
\xfec\xa3\xd1\xd9\xe8\x98\xc1\x86\xe1?\x8a\x17`\xae\x80\xd1\xc4\x00\x8c@$\
\x15\x8c\x1a@\x05\x03\x18\x19\x99\x98IN\xbe\x18\x06P\x02\x06>\x0c\x00nC 8\
\x85\x07\xf3\xe2\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeStaticBoxSizerHBitmap():
    return BitmapFromImage(getTreeStaticBoxSizerHImage())

def getTreeStaticBoxSizerHImage():
    stream = cStringIO.StringIO(getTreeStaticBoxSizerHData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeStaticBoxSizerVData():
    return \
'\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\x00\\IDAT8\x8dcddbf\xc0\x05\xfe[\xfd\xfd\xcfx\x8c\x99\x11\xa7\x02\x06\
\x06\x06&B\x9a\xff[\xfd\xfdO\x92\x01\xc8\x1a\xd0\xd90L\x94\x0b\x18\x18\x18\
\x18\x90\x9d\xcfx\x8c\x99\x11\x9bwp\x1a\x00SLv\x18\x10\x0b\x86\x81\x01,\xd8\
\x04\t\xc5=A\x03\xf0\x85<I\xe9\x80\x180\x0c\x0c\xa08\x16\x00\xdfV)\xcb\xfbF\
\xcf,\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeStaticBoxSizerVBitmap():
    return BitmapFromImage(getTreeStaticBoxSizerVImage())

def getTreeStaticBoxSizerVImage():
    stream = cStringIO.StringIO(getTreeStaticBoxSizerVData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeStaticLineData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x02\x08\x02\
\x00\x00\x00\xd3\x91\xbb\xe1\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\
\x00\x00\x00\x16IDAT\x08\x99c\\{\x7f-\x03e\x80\xf1\xc5\xdf\x17\x14\x1a\x01\
\x00\xdc\xcf\x05\t$\xbc\x9b\x82\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeStaticLineBitmap():
    return BitmapFromImage(getTreeStaticLineImage())

def getTreeStaticLineImage():
    stream = cStringIO.StringIO(getTreeStaticLineData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeStaticTextData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x08\x08\x02\
\x00\x00\x00r\n\x98\x87\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x01\xd5IDAT(\x91c\xbc\xf7\xe3\x1e\x03\x03\x03\x03\x03C\xcb\xce\xb6y]\x0b\
\x18\x18\x18\xcel=!\xc4!\xc4\xc0\xc0p\xf1\xc5\xc5\xc0\xe8\xd0\xe0\xec\xa0\
\xee\xa0\x0e\x06\xdc\x80\tB\xdd}\x7fw\xc1\xa4E\x10\xf6\xf5W7 \x8c\xab/\xae10\
0\xa8H)\xe3\xd1\x8f0b\xfa\xbeY\xff~\xfd\x8b.\x8cb``\xb8\xf3\xfa.D\xf0\xf6\
\xf3\xbb\x0c\x0c\x0c/\xde\xbf4\xcd\xb1\xd4\x0c\xd7\x9dy|\x16D\xfc\xe3\xcf\
\x8f\xcd;Z\x8d2\xcc\x94=\xd4-\nm\x98\x18\x18\x18N?=\xb3n\xda\xfa\xb0\xec\x10\
7]g\x06\x06\x86\x07\xaf\x1eB\x94^\xbau\x99\x81\x81\xe1\xcb\xb7\xcfyI\xd9\xff\
\xff3t\xd6\xf5<\xfb\xf2\xec\xe7\xdf\x9f\xf1S\x93\xe7\xf7.\x0c\n\x0ch\xefj\
\xf5puca``\x98\xb4u\n\x03\x0b\xa3\x9f\xb1/\'\x0b\x07\x03\x03\xc3\xbd\'\xf7\
\x18\x18\x18~\xff\xfb}y\xffeA5\xc1\xb6\xc0\x16V&\xd6\xbd\xee\x07\x0e-;\xf4\
\xfa\xcb\xeb\xc3w\x8f\\\xdaz)\xbe$\xb6\xc6\xbd\x8a\x81\x81\x81A\x8f\x81e\xeb\
\xcdmGW\x1ec``\x88I\x88\x87X~\xf6\xd09\x86T\x86\x1bon\xfe\xf9\xfc\xc72\xdc\
\x82\x95\x89\xf5\xe7\xdf\x9f\xe7\x8f]`\xe1eQ\x11V\xd9xa3\x03\x03\x83\x92\xb8\
"<,X\xba\x17\xf5\xb1\xf0\xb1\xf6wt\xb32\xb1200L\xdd8\xe3\xf2\xf6\xcb\xcf\xbe\
<\xbb\xf6\xe2:\x03\x03\xc3\xfe\xad\x07\x97j,;w\xf7\xc2\xe7\x07\x9f2\xaa\xd2\
\xb8Y\xb9\xc5\x05\xc4\x19\x18\x18\xe6\xac\x99\xcf\xc2\xc4\xf2\xe9\xc7g\x03\
\x19}\x06\x06k\x96\xf8\xf5I\xf7~\xdc\x83\xa0\xe85q\x0c\xd6,s\xae\xcdM\xda\
\x98\xc2`\xcd\x92\xb41\x85?N\x84#\x90\'}K\xe6\xad\xef\xb7\xef\xfd\xb8w\xf5\
\xcb\xd5\xd8\xb5\xf1\x9c!|\x8cNl\xf2\xa5*\xfb_\xee\x07\x00e\x00\xbf.\x9d\x85\
@\xd2\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeStaticTextBitmap():
    return BitmapFromImage(getTreeStaticTextImage())

def getTreeStaticTextImage():
    stream = cStringIO.StringIO(getTreeStaticTextData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeTextCtrlData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x00[IDAT8\x8dc\xdc\xf2h\xcb\x8b\xcf/\x99\x18\x99\x19H\x07\xff\xff\xff\
\x13\xe7\x15cy\xf5\xe5\x95\x9f\xa6/\x19\xfa!`\xdf\xdd\xfdL\x0c\x0cLd\xebg```\
ad\xa6H?\x04\x8c\x1a1j\xc4\xa06\xe2\x1f%\xfa\xff\xfc\xff\xcb\xb8\xe5\xd1\x96\
/?\xbe\xb00\xb1\x90\xa3\xff\xdf\x1f\x1e\x0e^\x00}A\x1a\x9c\x16\xb6&.\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getTreeTextCtrlBitmap():
    return BitmapFromImage(getTreeTextCtrlImage())

def getTreeTextCtrlImage():
    stream = cStringIO.StringIO(getTreeTextCtrlData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeToggleButtonData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x10\x08\x02\
\x00\x00\x00\x9d\x8f\x18q\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x00\xd6IDAT8\x8dc\xdc\xf0`\xe3\xfd\xb7\xf7\xff\xfe\xfb\xc7@:`afQ\x10\
\x92gy\xf0\xee\xa1\xbe\xb4\x1e\x13\x13\x13\x19F000\\{~\x9d\xe5\xcf\xdf?LLL\
\xcc\x8c\xcc\xe4\x19\xf1\xef\xdf?2-G\x06T0\x82\x05\xab\xe8\x85\xeb\x17/\xde\
\xb8\xf4\xef\xcf?&\x16&}\r=\x03M}\x92]a\xa0\xa9\x1f\x1f\x18\xfb\xfa\xd3\xeb\
\xb8\x80\x18^\x11\xdeE\x9b\x97>y\xff\x944#\xe0\xe0\xf7\xbf\xdf+w\xaf\x0e\xf7\
\x0c\x99\xb3}\x1e\x99F|\xfb\xfd\x8d\xef\x0f/;\x0b;\xdbo62\x8d\xe0g\xe7\xe7\
\x94\xe7\x9c\xbdn\xae\x8c\x924.5\x8c=\xa7\xfbL\xe4\x8d\xc8N\x17\x17\x9f\\\
\x1a\x1c\xe9\x82\x1aF\xb0\xb2`O]\xc4\xeagfb\x91\x17\x94\xbf\xf2\xec\x1a\xc3\
\xff\xffd\xe8gdb\x94\xe6\x97\x06\x00h\xc2A2\xbe\x98a\xcd\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getTreeToggleButtonBitmap():
    return BitmapFromImage(getTreeToggleButtonImage())

def getTreeToggleButtonImage():
    stream = cStringIO.StringIO(getTreeToggleButtonData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeToolData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x0b\x00\x00\x00\t\x08\x02\
\x00\x00\x00k\x06Az\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\x01\
\x19IDAT\x18\x95%\xd0QN\xc20\x18\x00\xe0\x8ev\x1bl1Q\x18\x18\x87\x1a\x8d\x0c\
L\xf4UL\x8c\x0f\x18O`<\x8b\x1e\xcd\xa3\x88\x84\xc0\x82\t1\x8e\x01\x1bn\xed\
\xd2\xf6\xff\xeb\x03\xdf\x11>k\xca\xa7\x95\xaa&\xab\x89g\xfb\xfdN\xa4@\xa5e\
\xba*\xd2\xdb\x93\x1bVc\x84\x10\xeb\xed\xe3\xdd\xb3\xfd\xcb\xee\xc5l9GD\xcb!\
^\xcd3\x94\xb4\xdd l\x85\x86 sU\xfd\xf9\xeeI\x83\xee\x1e\x85\n\xb4\x04\xa9@\
\xed\xc4\xee\xf3{\xbc\xfe\xdb\xcc\x7fcf\xb7X&\xf2R\x96\xc6\xa0M\xed\x86\xed\
\xf9\x8e\x17\xf8\xad\xf00\\n\x96\x16%\x0c\x0cd"\x13J\\w\x06\x86\x10!9W\x02\
\x10\xd0\xc0"]\x8cz#\xe62w\xcb\xb7\x81\x1f\xe4\xd5\x0eP\x83A4\xa0Qs)\x8a\xa2\
<\x0f\xceXV\xe4hL\xaf}\xc5%\xd7\xa8%\xa8JU\x19\xcf\xc7\xf1\xd7\xe3\xe0\x81Z\
\x941J\x1bN\xa3\x94|\xcb7\xb3\x9f8\xcdR\x97:\xdd\x83\xd3\xd7\xe1\xcb\xe0\xb8\
O\x08a\x14Y\x92$q\x127k\xcd\xfbh\x18\x05Q\xddv\xf7\x13{\xff\x9eG\x9f\x8e6\
\xe1\x0et\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeToolBitmap():
    return BitmapFromImage(getTreeToolImage())

def getTreeToolImage():
    stream = cStringIO.StringIO(getTreeToolData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeToolBarData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\t\x08\x02\
\x00\x00\x00\xb9VK"\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\x02\
\x07IDAT(\x91=\x92\xcdN\x13Q\x18@\xbf\x99{\xa7\xd3\xe9\x04\x83Pi:X\x04\xa4P\
\xd0D\x16\xe8BL\xc4\xb00&\xb8P^\x87\xe8{\xe8F\xe5%4At\xe1O\\\x11c\xd2\x96 4`\
\xd0\x18\x86\xd2\xd6\xce\x9d\xe9\xbd\xdf\xfd>\x17DO\xce\x1b\x9c\xe3\xec\xa9\
\xbd\xccd\xbb\'\xbb\x05/\x9c\x1d\xab\x1ak\xe2$>\xe9\xc7\xd7\xcb\xd7\xa4+\x01\
\x00\x0066\x9f\xd6\xbf\xd7\xa7\x8a\x93\xa1\x1f\x02\x00\x003\x80%{\xd0m=\\^\
\x93\xcf\xde?/x\xe1\xd4\xf8\xe4\xd7\xd6\xb7\x8f\xcdON\x0e\nn\x81\x05\xc4\xed\
8\x1a\x8d\x18h\xa1\xbc\x90d\xc9\xca\xea\xdd\xf5\xc5\xc7\x13\xc3\x15fFBdD\xc2\
\x17_^\xbd\xfe\xfcF\xfa&\xbfz\xf3\x1eZ\x1c\xbf\x18\x19\x8b\xdajcM/\xed\xd5\
\x8f\x1a\xa7\x7f\xda\x07\xbf[\xd3k\xd3\xc4\\\xbaP\x8a\x86\xca\xbe\xf0\x91\
\x90\x81\x89\xc8u\\OH\x1e\xb0\xf4Fe\'\xed&:a&Ox\x81W\x08s\x85b8\x1a\rG\xc7\
\xedcG@\xe0\x05\xcc\xec:\x0e\x01\x192\x86\x0c\x12\xfe\xd3\x12\x91\xb4l;i\'5i\
ml\x8e\x01R\xad\x94I-Yb{\x18\x1f\xae\xcc\xac\x00\x00Y\xab\xad\xd1\xa8]G \x19\
$\xb4l\x91\xd0\xa0!&\xe9K\xffL\x9d\x15\xc3b7\xebYB\xcbDl\x91P\xe9\xb4\xdfO&\
\x8a\x15\x00 K\xa9V\xdb\xfb\xef\xd4@u\xfb=$$"vH\r\x14\x11\xc9N\xbfK\xcc3\x97\
\xae*\xad\x90P[\x93\x99\xac\xa3\xba\x8dV\xf3\xce\xdcm\xe1\x08\x00@c\x07F\x9f\
\xf4\xe3\xf9\xb1\xda\x11\x1e-]Y:U\xa7/?l\x06\xf9\xc0\xb2\x95R\x88 \x17$Z\x9d\
\xa9\xf6\xfe\xafV\xdc\x89}\x91\x1b\x1f\xba\xbc~\xeb\xd1\\i\xf6<\xea\x83\xe5\
\xfb;?w*Q\x05\x19\xeb\xc7\x8d\xf9J\xcd\xcf\xfby/OD\xc4\xecll=\xd1Z\'\x90\x8c\
\xb8#\x8b\xd5\x1b\xd5b5\xef\xf9\xff\x8f8\x87\x98\xde\xd6\xb7\xb7\x9a\xdba.\
\x94 \x84+2=h\xfeh\x06a\x10@\xf0\x17E\x95U\x0b=\x19`#\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getTreeToolBarBitmap():
    return BitmapFromImage(getTreeToolBarImage())

def getTreeToolBarImage():
    stream = cStringIO.StringIO(getTreeToolBarData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeTreeCtrlData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
\x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
\x00\x01\x88IDAT(\x91u\x8fMkSA\x18\x85g&sC\x1b\xd46I\x8b\x11\x1b\xd1E?\x16v\
\xd5n\xac\xa2;\xfd\x15\xe2^\x7f\xa7\x82\xaeT*(1\x11\x03R\xeegs3w\xee|\xbc\
\xef\xbc\xe3\xe2*\xc4\x85\xcf\xee\xc0y\xe0\x1c\xbe\xb0\x0b\xf6\x97\xac\xcd>\
\xfe\xfa\xe4\x83o\xbd1`\xac7[\xfd\xedWg/\xd9\x06b3\xcc\x8a\xd9\xf9\xf4\xec`\
\xf7\xee\xe4\xd6\xed\xbd\x1b\xe3\x9d\xc1N\xa9\xca\xab\xe6j\xb3#7\x83Eg\xd1\
\xd6v]\x9b\xba6u\xa9\xaaZ\xd7@\xf0_\xc1xc\xc0\xd4\xa6\xceT\x9e\xad\xb2\xbe\
\xec_\x1c=JUV\xb5\x15E\xa2H\xc3\xed\xa1\xcc\xdb|Q\xfd@\x02\x088K\xbf\x0f\x07\
\xbb?\x8be\xd5\\;\xb0\x8f\x8f/^\x1c>\xd7\xa0\xbb6E\xfa\x9a\x7f\x93\x97\xe9\
\x97\xd3\xc9\xc3\\\x17\x06Z\xce\xf8<_\x14\xaa\xb4\xce\x02\xfeY\x12b\x881"!\
\x12R$\xe9\xc0Q$\xed\x1b\xed\xdb\xe9\xf8\xe0\xf3\xf2\xd2:so\x7f\x1a"%"\x89,R\
$\x08`\xd1F\x16\x91PZ\xb4\x16\xadr\xcd\xaa]U\xba\xda\xbb9\x86\x01\xbcy\xf2\
\x9a1\xf6v\xf9\xce\x05g\xc0 ad\x913.EO\x16\xaaX[\x95\xae\xd3k\xbd\xf2\xe8\
\x01\x81"uc8\xe7\x0e\x1d\x122\xc68\xe3\x82\x8b\xa4\xd7\x97\xda\xb5Y\x93\x15\
\xaa\xf4\xe8!@\x08!\x91I\'\x9c\xec\x1f\xcf\xab\xb9\xe0\x823\xce\xb9\xe8\x89\
\xde\x83\xe1}y49|?\xff\xd0=!"!\xc4\xb3\x93\xa7\x9d0\xda\x1a\x8d\xee\x8c\xd8\
\xbf\xfc\x06\xa3[\x18y\xf3\r\xb3\xdc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeTreeCtrlBitmap():
    return BitmapFromImage(getTreeTreeCtrlImage())

def getTreeTreeCtrlImage():
    stream = cStringIO.StringIO(getTreeTreeCtrlData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getTreeWizardData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x02\
\x00\x00\x00K\xd6\xfbl\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\x00\
\x02\xafIDAT8\x8d\x9d\x91\xc9OSQ\x14\xc6\xcf\xbd\xef\xbe\x16\x8a\x1d\xa0-\
\xb4\xd8\xd2bT\x86\x82+\t$\x1a\x12\x87\xa8\x7f\x00\x82J\xdc\xb84\xd1\x8d\xfa\
\x0f\x808\xc4\xb5\xd1\x8d\xb8Q\x17\xc6\xe0\xc4\x86\x85.\x1c\x12\x01E"(\xb1\
\xa8\xd0!<,}\xad\x1dh\xfb\xfa\xee\xbb\xd7\x05\t1\xf0\x18\xea\x97\xb3:\xe7\
\xdc_\xbe\xef\\\xf4*\xf2zh\xe2i\x99\xb1L\xd5T\xd8\x9e\x8aT\x05\xce\x01\x80s\
\xe8\xde\xdf%\x94w\x9a\xaa\x1d\xd5\x18cs\x85\xd9n\xa9*r\xd5e\xab\xb1TX\x10\
\xc1\xe5\xc62\x10\x90\xd9d6\x18DD0\x11\t\x11\tG\xcca\xb5\xd7\xdak\x1dV\x07\
\x05\xfa\xee\xfb{\x02\x08\xd2\xf9T6\xb7\xbc\x94\x8c\xd7\xef\xf4\x03\xf0\xfaJ\
\xbf\x94\xfe\xed\xact\xca9\xb9\xdd\xd7\x94\xc9g\xe4\x9cl2\x98\xe4\\\xc2a\xb2\
OK_\x15Z\xec\xf0\xb6K\x99\xc5\x90\x1c\xe6\x080\xe3\x0c!\xdc\xe6o\xf3U\xd5\
\xd5Xj4\xc6\xd2\xf9\x8c\x00x>\x1e\xc2\x1c/\xa5\x96\xe4l"\x9d\xcf\x14\x8a\x85\
x*N5\n\x00\x94\xd2\x89\xe8\xe7\x85\x94\xa4j*\xe3\x8chL\xe3\x9c\xc7\x96c^\x97\
7\xfa\'Z\xd4\x8ac\x91q\xce9FX\xcaJ+\xe1\x11 \x0e\x1c!\x14\xcb\xc4\x14\xaa\
\xa8T\x9d\xcaO\x03\x00BH\xd5T48y\xdfesm\xf3\x90\xeb5/\xcf\x13\x9f\xddW\xef\
\xf4\xff7\x82q\r\xeb\x0e\x92\x85\xe4\xcb\xb1\xe1\xd8\xf2\x12\xe3\x8c2\xba9E\
\x1fa\x14\x8c\xb7\x1f\xde\xb9\xf7f\x10#\xfcbr\xf8\xfc\xdd\x0b\x9b \x88nW\xc0\
B\x9d\xa3\xae\xc5\x1b\xe8\x7f>`5Zw\x18*JC(\x9a2\x1a\x1cu{\xdc\x01O\xa0\xd5\
\xd3\x12MF\xb9\xc8JC<x\xfb((\x05\x0f\x1f8\x94.\xa4\t&\x0c\xd8\\8\x04\x00T\
\xa3D\xd0\xd9_{\x8b/\x0bS\xf1\xc5\xb8\xc1d\xfc0>\x1aIF\x12\xb9\x84\xa2)\xcd\
\r\x8dG.\x1f\x1f\xfa\xf8L\xa1\xca\xd6.\xf6\xd5\xb66\x9flR4\xa5\xe7Z\xaf\xad\
\xdaF5\x1a\x0c\xcf\x86\xe7#\'\xda\x8eu\xb7wm7\x08\x11\x88 \x08\x9d\x1d\x07\
\xbf\x85f~\xce\xccU\xfb\x9d"\x11\xaf\xf4\\\xd2}\xaf\x13dE\x08\x90\xbf\xd2\
\xdf{\xf4\xf4\xf5\x8b\xfdi9eu[{n\x9d\xd9\x08\xa1\xff\xa9\x00\xb0j\xbbew\xe0\
\x87\xf4+\x15O\x95\xe6\x02\x00TF\x11\xc2\x08\xe1\x9bgo\xa8J\xd1\xb3\xcb\xf3x\
\xec\t\x07^\x02B\xc4\x84s\xb6RW\xcf\xf5es\xd9\x91O#\xb3\xb1\xd9-\x10\x08\xd0\
\xbf\xb5\xdao\xaci\xd8\xeb\xde\x93+\xe4\x17$i\xcd\x08\xd6\xdcB\xd7\'\x00\x88\
\x828p\xaa\x0f\x008\xe7\xebwH(\x11*\xd0\xfcFq\xb6T$\x11\xfd\x0b\x1f\xbaA\xa5\
4\xe8\x9e\xbf\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTreeWizardBitmap():
    return BitmapFromImage(getTreeWizardImage())

def getTreeWizardImage():
    stream = cStringIO.StringIO(getTreeWizardData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getUndoData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x16\x00\x00\x00\x16\x08\x06\
\x00\x00\x00\xc4\xb4l;\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x03wIDAT8\x8d\x9d\x94[h\\E\x18\xc7\x7fs\xf6\x9c\xbdds\xd9\xc4\xc4\xecfu\x9b\
d\x13So\x05\xfb\x12\xaa\xc5\xd24\xa8P\x84\xd4>\x89P\xfa\x90B\xde\xf4M}\x11\
\xa1\x88O\xc5\x0b\x88P\x03\x06\x05\t\x15!\xe0\x05\xc4\x98v\xdb\xc4\x1a\xb0\
\xa4\x95\nJDs\xdbfs\xdb&\xbb\x9b\xbd\x9d\xcb\xf8\xe09\xe1t7\xc9C\x0e|\xcc\
\xcc\x99\x8f\xdf\xff\xff}3\x0c\xec\xf3\x8d\x8fv\x0cN\x8e \xf7\xcb\xd9\xebS\
\xf6\xda\x18\x1b\x8e\x9e\xf4\x17\xff\xfd\xec \xd0=\xc1c\xc3\xd1\x93\xcdjr\
\xa2\xf7\xa5\x17\x0f\xca\xad\x06\xef@\xfb\xbb\xc1\\:0X\xdd\x0b\xaa\xcbChj\r\
\xf0\x07\x93#\xc8b\x99;%\x83\x99\x92\xc1\x95\xa9y\xae_\xba\xc4\xf6~`\xcfnPi\
\xcc\x83\xf7(B\x18\xb4\xb5\x07\x89vFy8\x1a\t\x87\xea\x94\xdcf:\x1b?\xd2\xc6+\
\xb1\xc7\x02\xbf$\xa6\x8c\xcc\xbe\xe0\xef?\x8f=\xd7\xe4YJ\xf4\xf6wS\xd0;Q\
\xfc\xcf\x00 \xd1@\x89\x80\xd2\x8c\xeak#Xk\xc5\xda{z\x9e\xd4\xbc\xc6\xe1\x87\
\xc4\xc6\xf3\xb1\'\xb4[\x89\x1b\xd6\xf2\xae\xe0\x9fG\xe3\xe7\x82\xe6\xdc\xb7\
\xbd\xfd\xdd\xe4\xf5C(B\xc5\xa3\xfa\\)&z9K\xa9\xb0\xc2\xe2\xc2M$~\x82\xf5\
\xf5\xa2\xbe%\x16\xf5\xe5\x16\xcc\xce\xa3\\K$\xd0+\xc1\xa2\xb2\rE\xa3\x0b\
\xd0A\xf8\xc9\xe7\xee\xb1\xb1\xf6{\x95\x1bU\x85\xd6G^\xe0\xd6\xd4\xaf\xb7\
\x0b\xd9\xf4\xf4\xe9!\x86v\x05W\xc2WV\xcbd2I\xba\xbb:\xc0\x13\x06\xa0X,\xb0\
\x9dKQ\xcc\xa5\x11\xaa\xc0\x1bx\x94\x92~\x98\xbf\x7f\x1b\xbb\xdb\x7f\x81\xa7\
\xab\xc4\x9d\xc9\xc0`\xf2\xea\xd8p\xb4\xef\xe6\xc4\xf2\xc4\xb1\xbe\x08y\xfb\
\xcc\xa7\x7f\xbc\xb1\x93\x9c\x91\xb5\xb4\x86c2\xd4\x98\x14\x942\x04k\r\xf06\
\xb7\xc3zUU\x0f\xdc\xe3\x81\xc1\xe4\xd5t\xb9\xa1oz|\x96\x8e\x8e\x8e\x9d\xff\
\xc7\xcf#\x8e\x9fG\xdc\xdf\xf2\xbf\xba\x95^[\xcb\xe7Z\xa5i\x98Ht\x0c\xa9\xd6\
\xca\xd53\x11\xb9z&\xb2\'\xd8\x86_[*\x84OO\x8f\xcf\x82\xda\xe9\xceS^{c\xfdJ*\
\xcd\x85dr\x13\xaf\xbfA\xea\xe5\ri\x99E\xb6\xa9a\x9b\x9a*\xd7\x95B\x1e@\xfb\
\xe2\xa3\xd6\x97\'G\x90\xf6#\xe4u\x85\xf6\xd3H\xe3\xe6\xfa\x9fO\x99\xb3\xd3a\
\xe3\x87\xcbu\x12\xd7YU:\x16\x8e+\xfe\xef\xbb\xf7\xdc\xeb+\x13wS-g\xed}7\xd8\
\xe7\x11\x16\x1eE-g35e\xc3(.\xdbf\x1e\xa8^\xad\x00kv\x92\n(Co\xad%\x80f\xc0\
\xefv\x95\xb7|)\xa1\xd5F\xb2\x1b\x7f)\x86)\xe6mA\xc3\x0e\xcb\x01\x8b]\x1c\
\xab.\x17\xce\\\x00\xe2\xf2\xc5\x86\x81\xfa:%\\2\xb4{K\xcbfKn\xab<\n\xd4\x00\
\x05\x1b*\x01\xe9~\x84\xc4."\x9a\xab\nO0\x88\xda\xd5\x13|\xbb=\x9eO}\xf3uB[M\
Y\xef\xbd\xfb1\xdf\x01>@\xb7\xc3\x02\xa4\xa7\x02\xea\x1c\x9e[\xcc\x03\x88x\
\x9c\xe0\x97\x1f4}\x12\n\x15\xb2\x13\x89\x9c\x99\x9c\xb3\xde\xb9\xf8)\xd7\
\xed\xf2\x1d\xa8\xd3\n)\\\x00w\xd9;\xe3\xa9S\xde\xc6g\x8f(\x91P@4\xf9\x02\
\xfa\xe3\xdbyCy\xf3}F\xec\x92M;\xcav\x18\xf6\xdarz\xcc\x89\x13\x88x\x1co\xa9\
\x84\x98\x99\xc1\n\x04\x10Z\x01\xf3\xec\xb1r0\xd4\xe4m\xf9g\xb1\xbc\xb08\xc7\
\x9d\x0f\xbf\xe2\xbe\r\xc5vg\xb9\x04\x9c\x1eW\xdd?Au\xaf\xddU\xb9G\xe9\nG\
\xc0Y\xf3\x1fm\'g6V(WF\x00\x00\x00\x00IEND\xaeB`\x82' 

def getUndoBitmap():
    return BitmapFromImage(getUndoImage())

def getUndoImage():
    stream = cStringIO.StringIO(getUndoData())
    return ImageFromStream(stream)

#----------------------------------------------------------------------
def getIconData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\
\x00\x00szz\xf4\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\x04\
\xc3IDATX\x85\xa5\x96klSe\x18\xc7\x7f\xe7\xf4\xb4]/g\xed.t\xed`\x97v\x1b#0\
\x1c\x97\x989\x83$\x88\xe0%& \x015x\xf9d\xfc\xc2g\x8d\x891~2&F\xe3%j\xbc\xe0\
\x07\xa31!\n*\xc1\xcb\x07\xa31fH6\x184DC\x028\x1cs[\xef\xac;mO\xd7\x9e\xf3\
\xfaa\xa1Z\xd6\x8e\xae{\xbe\xf5}\xcf\xf3\xff\xff\xde\xe7}\xfa\xe4\x85\x1a\
\xe2\xe8\xa7\x9f\t\x80\xafO}/FF\xcf\x89\xd1\xf3aQK^-!U\xdb\xf8\xf9\xb7\x11\
\xa1\xaa*\x00\xaa,\xb07\xaf\xc1\x85A*\xa7a\x172Wgc\xec\xde\xb9\xa3j~\xad\xa1\
\x00|~\xec+\x11\x0c\x06iT\xc0\xaa(444\x90\x93m\xb8%\x83\xb9\xa2 \x93\x8cqy:\
\x8a\xa6i\xc4\xe31\xfaB\x1d(v\xf7j\xbd\xff\x03\xd8\xbc\xb1\x17\x8f\xdd\xc1\
\x95S\xc7\x89\xcdD\xe8>\xf8\x18\x91\xc8,\x92\xe2d|\xfc<\x81\x80\x1f\xd5iEQ\
\x14,\x16\x0b\xa9\xb4\x8e\xc5\xb2\xb0D\xec\x87\x9f~\x11\xa1.?\xc9\xb4\xce\
\xf0\xf6\xad\xd2\x17_\x9e\x10\x87\x0f\x1dX\xb6J\n\x80\x963X0\xf2\\\x0e\x87\
\xb9~v\x8cdk;9\xbb\x93\xd4\xf4$\xed\xbd\xfd\xe89\x1d=\xa7\x97\x92"\xb3\xb3H\
\xf2R]\x9f\xcbN\x93\xc3\x8d\xc3\xddBt\xea\xbaH\xe8E`\xb1w\x1ey\xf8\xa1\x8a \
\x12\xc07\'O\x08\x9b\xc3\xcb\xc4\xc4_K>\x88D\xa2\xcc\\\xfb\x9b\x8f?\xf9p\xd9\
\x93\xbc\xf2\xda\x1bb\xd7\xbd\xbbp:\x9cx\xad\x12\x97#i\xce\x9c\r39\x97g\xef\
\x96\x0e\xfa7l\xa0Q\x16t\xaf\xef\x97\xbe\xfd\xfeG\x91\xd3u\x1e?\xb0_*\x89\
\xbe\xf7\xd1\xd1\xb2\xce>\xf2\xec3\xa5\xbd\r\xad\xad\xa2\xbb-\x80\xcb\xabr|\
\xe4tE\x90W_\x7fS\x0c\x0f\x0fc\x9a\x06\xa6i\xf2\xeb\x99\x8b\x8c\xfd9\xc5`\
\xef\x1av\xdc9\x80\xc3\xd1\x80\xa6it4{\xf0\xf9|\x8b\xbd\x95\xc9T\xff\x17\xdc\
\x1a[}-\xa2=\xd0\xc1w\xe1\x0bUs\xde~\xff\x03\xe1r\xb9\xf0x<d\xb39\x92\x89\
\x04\x81\x8e\x10\x89\x99+D\x13\xf3\xf8\xac2\x9d\x83\xdb\x18\x18\xd8\x84\x0b\
\x83l6[;\x00\xc0\xdd\x9dkEks3\'/\\\xbcm\xde\x91\xc3O\n\xb5\xa5\x89\xf6\x9e~\
\x9a\xfcmXmVdI\xc2\xedV\xf16yq:\x9cLMM\xad\x0c\xa0\xd7\xeb\x11\xc1\xe6\x16lj\
c\xd5J\xec\x1b\x1a\x12*\x82lZ#2w\x83\x91\xe9i\xe9\xc5\xe7\x9f\x13n_;\x8d\x8d\
*6\x9b\r\x8f\xc7\x83\xaa6r\xed\xda\xc4J\xec\x17\xe3\x8e\x16\xaf\xd8?\xb0\xa9\
\xea$|\xea\xae!\xb1\'\x14\x12[\xdb\x02U\xbfy\xe1\xa5\x97\xc5;o\xbd[\xdf4\xf5\
\xbb\xddb\xe7\xbau\x15\x93\x1f\xdd\xb6E\xec\x0ev\x8b\xc15m5\x8b\xd75J75\xb5\
\x88\xbe\xb5~\xec\xaa\x87c\xbf\x9f\x96\x9e\xb8g\xa7@\xd3\xb8\x1e\x8b2\x97/\
\x10\x8eEj\xd6\xad\x0b\xa0Ku\x88.O\x0b}\xc1ndY"\x9b\xce\xf0O"Nl>\xc3\x1f\xa9\
\xc4\x8a4\x95z\x00rE\x899=C*\x9e\xa4A\x12$2:1]\'Q\xc8\xafXK\xae\x07 \x9a\xcb\
J\x99\xa2I|>\xcd\xc2B\x81\x9cQ \xbf\x90gV\xd3V\\\xd1\xba\x00\x00\xec\x92\x82\
V\xd01\xad6\x8a\x86\xc1\x95\x1bsu]g\xdd\x00\xb9\xa2\x8ebJ\x88|\x0eI\xaa\xffY\
P7\x80Ci S4\xc9\x1a`\x91\xeb\x96\xa9\x1f\x00\xc0b\xb1\xa0XL\xac\xab\x90Y\x15\
\x80a\x18\xcc/\x18\xab\x91X\x1d\x80U\x11\xa86\x0b\xbaY\xac[\xa3\xe6906>*\xe2\
\xc9\x0c\x00\x0e\x9b\xe0\xc8\xbeC\x98B\xa1P\x94V\xd5\x035\xb5\xef\xd8\xf8\
\xa8\xe8\xed\xe9-[\xdb\xd1\xdd\x87U\x11x\x1dn,&\x18\xed~\x0e\x1c~\x9a\xf5\
\x1b{\x00\x08\x06\xbb\x97\xe8$\x93)\xd2\xe94\xf7\xefy\xa0\xe4{\xdb\nT2/\xcc/\
VB\x96el\xc8\x18\x98\x98\xa6Y\xda\x1f\x1a\x1a\x02`br\x96H$\x82\x85\xc5\x07l\
\xbe(\x93O&\xca\xb4\x96\x05\xa8d\x0e`U]\x00\x14\r\x19\xab"\xd0r\x05l\xb2\x8c\
\xb3\xc9S2\x07\x08v\xfa\tv\xfa\xcb\xc0\xcf]*\xb7\xac\x0806>*\x00*\x99\xdf\
\x14\x02\xb8Q(\xd0\x86\x1b\xc5b\xc1\xedv\x13\n\x85\x96;\x0f\xa9\x9c\xc6\x83\
\xf7\xed*\xbb\xf6%\x00\xd5N]\x96\xe4v\xb2\xf7\xd0A\x00T\xb3H"\x9bg\xe3\xe0f\
\x06\x82\x9dUs\xe6\xb3E\xc6\xc3\x97\x96\xac\x97\xd1\xd4b~3\x84\x10\x14\xb5l\
\xe9:n\x17SW\'\xd8\xbcm\xfb\x92\xa6/-\xfc\xdf\\\x08\xb1\xaa\xf9~k\xc4\xe3q\
\xfaz\xd6W\x14,]A\xf8B\x98T2UQ\xc0\x17\xe8*\xfb\xed\xb0\x95\xbf\xb8|\xbe\xb6\
e\x01\xaa\x99C\x9d/\xa2\xe5br&ZF\xd7\x19\xf0-\xeb\xf1/\x93I\xe0\xa6\xdf\x1f+\
\xe2\x00\x00\x00\x00IEND\xaeB`\x82' 

def getIconBitmap():
    return BitmapFromImage(getIconImage())

def getIconImage():
    stream = cStringIO.StringIO(getIconData())
    return ImageFromStream(stream)

def getIconIcon():
    icon = EmptyIcon()
    icon.CopyFromBitmap(getIconBitmap())
    return icon

