Logo Search packages:      
Sourcecode: wxwidgets2.8 version File versions

flagart.py

#Boa:PyImgResource:

#----------------------------------------------------------------------
# This file was generated by famfamfam_flags.py
#

""" 
See: http://www.famfamfam.com/lab/icons/flags

FamFamFam Flag icons are available free for any purpose
Copyright Mark James (mjames@gmail.com)

This module is (c) 2006 Riaan Booysen and licensed under the Python license.

"""

import wx
from wx import ImageFromStream, BitmapFromImage
import cStringIO

catalog = {}
index = []
class ImageClass: pass

#----------------------------------------------------------------------
def getAEData():
    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\x00\xddIDAT(\x91\x85\x8e\xb1M\x03P\x10C\xdf\'\xbf\xa4\xa3\x8a\x04]\x98"\
%\x1d\xf3\xd0EL\xc1\x14i\xb3I6 \x12L\x80h\xce\xbe;\x8a\x04\x01E\xc8\xd3\xc9\
\xba\xc2\x96=\x9a\x1f\n\x16\xcf`0\x14\x04\x18\xe2\xcf3\x016\x1b\xa0\xabF\xd5\
\xd3c\xba2\xcbn\xbb\xec\x92\xd2.\xa9\xac\xd4\xeee7\x01\xe8~{\'\x93\xcc\xd7\
\x0fe\xa6ZJ\xa9\xa4TdD\x85Rw\xd7w\xa7\x86\xae>\xba[\xda>l\xfb\x0cc\x8c\xc3\
\xfda\x16\x8cL\xec\xb6\x91\xcf\xb9\xbb\x1b\xa8\xaa\t\xe0l\xe9r`\x0c\xdb\x13\
\xe8t\xdb\xad\xf8?0\xba\x81Y0\xa4\x8e\xc0\xee\x88\x7f\xf6twU\xcd\x82\x85\xdd\
\x12RK\xeb\xf5:"$\x9dTR\x84-;W\xab\xd5~\xbf\x9f\x05W2\xcbeK8o\xad#\xb6\x8fj;\
\xbf\x01\xc6\'\xd4\xaf\xbb\xe1\x02_z\xc6i\x06\x81\xb8\x0e\xd7\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getAEBitmap():
    return BitmapFromImage(getAEImage())

def getAEImage():
    stream = cStringIO.StringIO(getAEData())
    return ImageFromStream(stream)

index.append('AE')
catalog['AE'] = ImageClass()
catalog['AE'].getData = getAEData
catalog['AE'].getImage = getAEImage
catalog['AE'].getBitmap = getAEBitmap


#----------------------------------------------------------------------
def getAFData():
    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\x01mIDAT(\x91U\x90\xbdNUa\x14D\xe7\xe0\x01\x01\x7f\n\t\x02%\x15\xe1\x05\
(\xa9-\xedi\xe05,\xef\x1bX[\xf2\x04t\xc6\xa8\xb12\xb1\xd2\xc2\x88\x891\xc6N \
\xc1\xe4&\xdc\xb3gf\x7f\xdf\xb6 &\xba2\xed*f\r\xfb\xfb\xfb\xf3\xf9\x1c\x00\
\x00I\xbf\xae\xae\xfa\xf2r\xb7\x01$\x00\xe0\xd9&\x9e\x1f\x03\x01\x08\x00\xc6\
\xeb\xeb\xeb\xd9l\x06\xa0\xf5\xd6[\x87=d\xbbc\x95\xbdbw\xe9\xe9ny\xefFMl<}q:\
\x8e\xe3\x08\xe0\xe2\xf22\xed\xcc,\xbb\xa4\xa2J,\xb2\x93\xbf\xef\xd6\xb7\xed\
9\x1d\xdb\xeb;\x10\xc6\xde{k-mgZ*\xbb\x80~r\\-\xeb\xcd\xbb\xfa\xf0\xde\xae\
\xc9\x93L%\x11X\x92\x94\x99\xb2EJ*\xb2\x8e\x8e\xf4\xf6\xb5\xce\xce\xfa\xe1a\
\x0f\x9a\xa49e\xb0\t\x0b\x8c\xb1Xd\xa6%\xc9d\x94\xd4\xd7V\xf3\xe0\x00S\x0c\
\xab+\x15\x91\xd1\xa7\x9c\xc2d\x12\x81\xf1&\xc2\xb6$\x92$\xbb\xd4~|_\xda\xda\
\xe9\xf7\xee\xe7\xf9\xd7a\xb1\xb0\x11\x19J1\taD\x95\xed\x88\xb8uzD\xbd|\x15\
\x8f7\xcb\xb9\xf2\xf9\x1cd\xaahF\x86\xbb!\x8c\xb7\xf9%E\x04\xc9\x8a\xa8/\xe7\
k\x1f?u\xb2G4\xd2D\xb4I-\xdd\xfe\n$\x1fml\xdc\x9e\x06\x05q\x90\x06r\xb0\x97\
\xa4\x87[\xd8}\xb0\xe1t\xf6\xc4\x02\x03\xfe\xe7'\xd0\x81\xfcgO\x80\x8b= \x80\
\x04\xd6\xf1\x07\xfbEiS4\x8b\x8d>\x00\x00\x00\x00IEND\xaeB`\x82" 

def getAFBitmap():
    return BitmapFromImage(getAFImage())

def getAFImage():
    stream = cStringIO.StringIO(getAFData())
    return ImageFromStream(stream)

index.append('AF')
catalog['AF'] = ImageClass()
catalog['AF'].getData = getAFData
catalog['AF'].getImage = getAFImage
catalog['AF'].getBitmap = getAFBitmap


#----------------------------------------------------------------------
def getALData():
    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\x80IDAT(\x91M\xd1?\x8fMa\x14\x85\xf1u\xde\xf3r\x1d\x17\x99\x8c\x89\
\x98h\x14\x12\x89D\xa5\xf41\x90\xa8T\xd3\x88f\n\x8ai\x94\xa2\x11\xa2\xd1\x8c\
\x86\xda\x17\xd0*4:\xbe\x82?\x13\x93\xeb\xba3\xf7\xcey\xf7Z{o\xc5\x90h\x9f\
\xe6)~\xdd\xe7\x015\x80\x02\x00U\x10Q\x81\x118n\x06\x08\x10\x10@\x00#P+\xb0\
\xf9\xe29\x80t\x8f\x88\xea\xbe\xfbky{(\xc5\xfd\xf5\xfe\xe1\xfdi\xefR'\x0b2\
\xc8/\xaf\xdeT\x00\x00\xb4\xf7\xbd\x0f\x7f;[\xdd\x19\xca\xf5\xe5\xf8x\xb6\
\x94\xd9\xdd\xa1\xb3\xfdx\xf6s\xb1=-2;yq\xd3\x80\x1a\x81tO\xf7\x94n\xf4\xb9\
\xf3c1\xb6\x96\xb4\xd3\xd2\xcb\x83Fk\x0f\x86>\x8ca\x16\xa2\x80R\x0c\xe9\x9ed\
\x8a\x9f\x0e\x8f.\x85\x8c\\6\xfbz4\xb6\xb1m\xb8>,\x96\xd1,\xcd\xc2X\x80\x82D\
\xbaBL\xea\n\x1c\xe4\xc3i\xd7Zk\xad\xed\x9c-kaW\x93a\xcd[K\x12@\r %P\xee\xbc\
\xd6\xf9\xe5I\xbe\x9b\xad*M\xd6\xde\xcfck\xd2M\x94aL\x1aH\x03\x8a\x01\xa0\
\x92\xa6\xd6\x06\xd9\xd3\xbd\xdf\xb7&9\x1f\xdb|l\xf7Nu\x8f\xbe\xcd\x07Y\xd2`\
\x16\xae\xd5\xf1!\x9cA\x0b3\x98=9\xd7\xf7\xe2\xcd>\x0fJ\x9c\x11w\xd7O\xb8Y\
\x92\xe9\n\t@\x05\x90T\xbfq\xa1\x90A\x82\x16\xd4\xf6\xda\xf9$\xc3\x19R\x91@\
\x8f`\xba\x02\xe8>\x02\x00\xe2?Q\x01\xf6\xcf\xf5\xaf\x12`\x00\x80\x11\xf8\
\x03e\xfaB@$q9K\x00\x00\x00\x00IEND\xaeB`\x82" 

def getALBitmap():
    return BitmapFromImage(getALImage())

def getALImage():
    stream = cStringIO.StringIO(getALData())
    return ImageFromStream(stream)

index.append('AL')
catalog['AL'] = ImageClass()
catalog['AL'].getData = getALData
catalog['AL'].getImage = getALImage
catalog['AL'].getBitmap = getALBitmap


#----------------------------------------------------------------------
def getAMData():
    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\x13IDAT(\x91UO\xbdN\x9bA\x10\x9c\xfb|\x95\xddR\xa0\x88\x967\xa0\xcc\
\xd3!\xaaH.\xd3$\xb4<\x1a\x12\n\x92\xf5a\t\x12n\xe7\'\xc5\xd9\x90\xacV\xa3\
\x19\xed\xccj\xb7\xd5\xf55\xd6\x15\xb3l\x8fa\x12c@20\x1bgb\xa0\xe3pX\xee\xee\
\x00\xc4F\xb2\x9166\xc8H\x99(\x81\x0c\t\xe9\xb8\xdfw,\x0b\x90\xfcz\x86\x14\
\x19>\x8dC\xa6\xea\x14\xabBU\xbb\xbc$\xd0\xb1\xaeq07I\x98\x8e\xe9&\xc3\n\x99\
"X\xa92\xd0/\xb6?ny\xf3\xc47\xcbdH\x93\xaa\xf2\xbf\xa4\xcaU\xfaR\xbb\x9fx\
\xefc\xd0\xb6h\xd2\xa2\xeb?\x9f(\xb3\\\xa5)\x81?}\x8c\xcf+>n\xa9\n\xe9\xaaHs\
\xfd\xfc\x1f\x00\xda\xef\xef\xe8_\xbf\xe5\xf51a\xcc\xa8>\xd1eU,\xb8b.\xbb\
\xab\xa7\xfb\x87\xee\x050\x13\xc6\x15}d*.Oi\xc2\x8c\xe9\x18\x1d\xddGd\x08\
\x9b\x0b\x80\x00[#\xda\xc9\xd1\x16\xb5\x08R,\x83x\xa7W\xb4\x97=\xf0\x06\x0f\
\x98g$x&\x98\x92\x80a\x02[\xfc\x05\x18\xe6\x87\xcd\x06u\' \x00\x00\x00\x00IE\
ND\xaeB`\x82' 

def getAMBitmap():
    return BitmapFromImage(getAMImage())

def getAMImage():
    stream = cStringIO.StringIO(getAMData())
    return ImageFromStream(stream)

index.append('AM')
catalog['AM'] = ImageClass()
catalog['AM'].getData = getAMData
catalog['AM'].getImage = getAMImage
catalog['AM'].getBitmap = getAMBitmap


#----------------------------------------------------------------------
def getARData():
    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\x019IDAT(\x91M\x91\xbdNUQ\x10\x85\xd7>l\x0f(\xa1\xc0\x1b\x0c\x8d\x85\
\x95\x11K\x13J\x1a\x94\xc4G\xf0\x01lH(\xad\xa9y\x1ebl\xb4\xf3\xe7\rhL\xb0&\
\xb9\x91h.r\xb2\xef\xcc\xb7,\xce\x81\xdc\xd5\xcc\x97\xc9\x9adfMy\xf7\xc3\x8b\
\xd0(DC\x84BjA\xc0\x104h#\x04}\xa7\xfa7\xf4\xfe\xd9\xe8\xb6]\xb0\x90\xc0\xe9\
\x92\xac\xa5\xba\xc4\xe0\xb4\xd3>\xf9\xbe\xa8Ch\x89\xae\x97\xc6\xc2J;\x11v\
\xe0\xc0a'\x13\xcf\xd6\x8b\x1a\xf5\xf4\xe9\xfc\xc5\x93\xd9\x12Y\x92\x8de\x19\
l\xdb\xb2\xf1\x88\xd8\x0f\x8av^\xce\xeb\xf3-f\xbd$\xd9\x96e\xd9\xb7_rq\x8e\
\xa3\xdb|\xeb\x8d#\xdf\xa9\x14\xed\xcf\xd4\x8d\xe7N\xbd\xb1\x0e\x9f\xe1\x97\
\xf3\xd2\xff>yU\x12PW\xdd\x1a'\xfa\x03\rs\xa9y\xe3p\xd5_l\xa0^\xfcao\xcb-m\
\xebn\xdd7~\xf4\x1a\x1b\xcc\xcd\xe4\x06\xf5\xd5\xdf\xe6Y\x8f\x7f>\xfe\xb0\
\xa6\xab[\x07\xba\x0f$\xefSbJ)\xd1\xeeC\x9d}\xdd\xae\x1d\x14u;\xebS\xa0i%JJZ\
\x81\xb0@\xe9\x92\xd8\x92Dy\xf5\xf1\xe6w\x9b\x1e9\x04C(A\x81\x1a\x02\x8d\x1c\
H(\xa4^\xff\x01\xf6\x01p\xe7$\xc8U\xac\x00\x00\x00\x00IEND\xaeB`\x82" 

def getARBitmap():
    return BitmapFromImage(getARImage())

def getARImage():
    stream = cStringIO.StringIO(getARData())
    return ImageFromStream(stream)

index.append('AR')
catalog['AR'] = ImageClass()
catalog['AR'].getData = getARData
catalog['AR'].getImage = getARImage
catalog['AR'].getBitmap = getARBitmap


#----------------------------------------------------------------------
def getATData():
    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\x00\xe9IDAT(\x91}\x91\xadnBA\x14\x84\xbfmoj\xd077\x08\x1c\xa65(\x1e\x0c\
\x8d\xe7\x810\xbc\x01\x9e\x17@\xb5\x82P\\k\xf6\xfcL\xc5\xde\x14hH''_FL6g\xe7\
\x14qU\xde\xfb\x87S\x04\xac\xd7\x802\xc9$B\x1e\x84\xcb\x1dw\x99\xe9\x86_\xdb\
m\x07\x80\xf4\xfeA\x04\x112k\x1c\xa7\x9a\xac\xaaV\x99\x95\xd9,\xa1c\xb9\xd4\
\xeb\x1b\xfd\x80R\xeeD(B\xeer\xbf\x1a\xf7Z\xeb\xcb0\xe4nWN\xa7S\xdf\xf7\x80$\
\x84\xd0\x1f\xd5Z\x1b'\x93\xc9\xe5ri+\x8d\xa9_\xf3X \xa9\xbb\x86\x1e\xbe\x7f\
\x9b\x972\xb3\xd8bQV+\x9d\xcf\xdcl,\x0f\xc5\xdd7\x88(\xc3\xf0\xb9\xd9ty8<\
\xef\xf7:\x1e\x19k\x19;\x19\xd9\x8c\x1b\x1e\xcc\xe7@\x97\xf0d\xcet*3<p\xc3\
\xac\x98\xe1N\xa3{k\x9c\x88\x84\xf2}\x7f\xc8\x7fn\xdc\xf4\x03|\xd6ZM\x8alr;\
\x00\x00\x00\x00IEND\xaeB`\x82" 

def getATBitmap():
    return BitmapFromImage(getATImage())

def getATImage():
    stream = cStringIO.StringIO(getATData())
    return ImageFromStream(stream)

index.append('AT')
catalog['AT'] = ImageClass()
catalog['AT'].getData = getATData
catalog['AT'].getImage = getATImage
catalog['AT'].getBitmap = getATBitmap


#----------------------------------------------------------------------
def getAUData():
    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\x02\x0bIDAT(\x91M\xc7OHSq\x1c\x00\xf0\xef\xdb\xdehK\x9d\xd3\xb9\xb6i\
\xcf\xb6\xe5"\xe7\xa6\x1db\x0b\xb3\xc2\xb2\x81\xd9""(\xe8\x94\x15\x1d\xa3\
\xa0d\x87.E\xc1@\x11:fQ\xd0%\xb0F\x041\x85(\xad\\D\r\x13L\x02\xdd\x16\x195\
\xdb\xd2ml{\xbf\xf7\xfb\xdbU\xf8\\>\xd2\xc7\x91\xdb3\xc6\x8e\xe8\xd4\xfaX1.s\
~\x85\x87\xaf\xb7\xfe<\xbc\xb7}\xf0~\x01\xaaE\x00\n@\x07/\x0c$\x1e\xbe\x04X\
\x07\xc0\xd2Pd\xecQ\xb4\x8f\xd8\x154\x9f\x12H\x95vx,6\xcb\xeb4\xfa\xb2\xf8\
\x9bQ\xaebr.\x12\x90e)\xb3\xba\x91\x98]y2:.\xa5L&\xe7\x9d\xbb\xfa\xc2_R.sM3\
\xd4\xd7i\\\xaa\xa98f<P\xa4\x12FXq6\x86\xf7\xbbc\x13s.\xa5i\xf2\xde\xb8\xee\
\x9d\xff\xb8\xae\xab\xc7\xe8\xebdV\x1b(\xae\xad\xc1 Q\xdc\xe9\xed\xdd\x88\
\x8a\x13\xfd\x1d\x00\xf0=\x9b\x8fM\xccE/\xf79\xacu\x005]\xf1\xf40X\xad/\xb8\
\xebO\xbd=g\xb0\xc4\x9b\x83z\x7f\xa0dn9r\xd0\xab\xd8\x1b\xae\x0e\xefS\x119{\
\xccg\x90\xa5\xa3\xbdn\x00\xa4\xf7K\xad\xf9\x06\xc7L\x16\x91\x1a\xcaVuSK\xa5\
\xe5\x8a\xde\xc2\xd5\xe7\xc9_^O\xcbd\xe2\xdbZ\xbeR\xd8P\x9b\x1a\x8dO_-\xae|}\
\xaf\xff\x9c\xe9\x0c\x0ctW\x8b\x95\x0c1e\xf0\x16\x99\xe2\\\xbe2\x9f#L\x88dju\
\xed_E\x08qf\xa8\xebq|\xc1d4d\x16\xde\xe8\x00(PN(?u\xc8s\xf3b\x08\x13F\x19\
\x07\xce\x08\xa6\x9cs\xc1\x84\xa6\xd1\xd1\x07\xc9R\xb9\xc6\x19\x03\xa0:\x00\
\x8c)\x13B\x84\xf6\xb4\xb5;\xcd\'\xc3\xbb5L0\xa1\x98PL\x98\x8aI\x9b\xc3<r\
\xa9W#\x8c1\x01@e\x00\xcc9on4M\x7fH\xf7\xec\xb2\xcd~\xfa\xa18\xcc\x9a\xc6\
\x98\xe0\x94\n\x15\xe1k\xe7C\xbe\x9d\xdb4\xcc\x9eM/\x01 \t \x02@\x01\x10\x00\
\xde\x84n\xae\xb7\xff\xc6\xf2\xdb[\x00\x1c\x00\xfe\x03\n\xf8\x1b\xa4\xf3\x04\
q\xa6\x00\x00\x00\x00IEND\xaeB`\x82' 

def getAUBitmap():
    return BitmapFromImage(getAUImage())

def getAUImage():
    stream = cStringIO.StringIO(getAUData())
    return ImageFromStream(stream)

index.append('AU')
catalog['AU'] = ImageClass()
catalog['AU'].getData = getAUData
catalog['AU'].getImage = getAUImage
catalog['AU'].getBitmap = getAUBitmap


#----------------------------------------------------------------------
def getAZData():
    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\x01nIDAT(\x91M\x90\xbdjTa\x18\x84\xe7;9\xbb!k\xc0F$?D\xb3j\xab\xa0\xb5m\
n"\x17\xb0w`\x15\xbc\x834\xa6\xdb\xe0%h\xe3\r(.\xa8\xd8\tY\xbbUD\x11m\xd4\
\xc4D\xf7|\xef\xcc\xbc)\xd6\x80\xc3\xc3\xf0\xc0tS\xf0\xe85\xe6\xc4"\x06h\x98\
 @\x82\xfe\xd7\xd5 Q\x89\xb6iq\xca\xbd\x9d!\x00\'\x9c\xa9L\x1a\xb2\x99I\x9bF\
\xc8\xb4\xc3\x19\xcag\xe3W-\x06\x03,\xb5_\xceB\x862\xc3\x962\xa4H\x843\x9cU\
\xaev\xc8[\x97\xfa\xe8\xaf\x96I)7\x0e\x0e\xea\xb7\xefiA2\x99\xa4I\x93\x19a\
\xd2\x11\x8eH\xb2\xbf\xb6\xf6r<n\xd14 \xa1H\tA\xcd\xff^\xdd\xdd\xedml\x1e?\
\x7f\xd1\xbb\xbeu<\x99\xfc\x99N3hFFm\x80\xc6\x92\x13\x96\x93\x12\xb9<\xbc\
\xd9\xdb\x1e~\xde\xdf\x1f\xdc\xbb\xbb|m{\xe5\xf6\x1dQ"E\xd9I\xa0\x01P\x16\
\x0fT\x96Pw\xf4\xbe\x9b}\\\x1f\x8d~>y:\x9f\xcd\xce\xde\xbc-\x1dKe\xe9\x88J\
\x03m\x05$J\x91\xa2\x19n\xf2\xeb\xe3\xc3\xaca\xf1\xd7\xf4\xc8\x11^L\xe6\x92y\
\n\xb4;\x0f1\xba\xaf\x0f\xbf\x15bXU\xac\xaaQ\xa3BaV3L\x8a\xb4n]\xf6\xbbOhq\
\x82\x08\xae\xf7\xaf\x84H\x93b\x98\xd1#\xcd\xb0(1)I)u\xc2\x0f\x14<\x00N\x00\
\x02\xf5\x02\xfe\'\xbc\x10\x03\x04Vq\x0e\xae\xdce\x0f\x0f\x8e\x9dx\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getAZBitmap():
    return BitmapFromImage(getAZImage())

def getAZImage():
    stream = cStringIO.StringIO(getAZData())
    return ImageFromStream(stream)

index.append('AZ')
catalog['AZ'] = ImageClass()
catalog['AZ'].getData = getAZData
catalog['AZ'].getImage = getAZImage
catalog['AZ'].getBitmap = getAZBitmap


#----------------------------------------------------------------------
def getBEData():
    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\x00\xeeIDAT(\x91m\x91AJ\x83a\x0cD\xdf\xa7UDT\xc4\x8dt\xe1\xc6\x0bx!o\
\xd2[\xf5:\xd5]\x05W\x8a\xe2*3I\\\xf4\xff[\x15\x87!\xab\xbc\xcc@\x06\xbf\xf5\
\xf1\xceE\x00TQ\xd7\xd4'uKq\xf0\x02X\xadV@UU\xd5\xd9yr\x95\xe0\xd1>\xc6G\x97\
\xeaG\xb7\xd4vK_\xeb\xf5\x02\x80\xden_233\xab\x04\xd9\xad\xc9\xa9\xdeDG\xb44\
\xee\xee\xa6\x84\xaa\xceLgZ\xea\xce\xee\xe8v\xb7\xba\xa3;:\xb4\x03\x90& 3\
\xbd\x93|\xb8\xfd\x1f\xc0\x0e\xb0S\xd2\x0f \x0e@\xa9c\xaa\x84\xbdO\xb0\xedP\
\xfc\x06\xe69'\x8c}%I\x11a[\x11\x7f\x13Z\xfb\xf3mo\xe7J\xd6\xac\xa9\xf7~\xfb\
D\x1d\xd1\x16N2='x\xb9\\J\xb2s\x0c\x81\xc6\x10\x18\x84\xcc\xbd\xc9\xdc\xb9`\
\xfc\xf9\xf4\xe6\x99X\xe0\xa2\xcc\xcd\x19\xf5\xc6\xeb\x03\x80\xe1\x14\x9e\
\xe0\x1b\xafZe\xef\x08@\x1fr\x00\x00\x00\x00IEND\xaeB`\x82" 

def getBEBitmap():
    return BitmapFromImage(getBEImage())

def getBEImage():
    stream = cStringIO.StringIO(getBEData())
    return ImageFromStream(stream)

index.append('BE')
catalog['BE'] = ImageClass()
catalog['BE'].getData = getBEData
catalog['BE'].getImage = getBEImage
catalog['BE'].getBitmap = getBEBitmap


#----------------------------------------------------------------------
def getBGData():
    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\x07IDAT(\x91mN1NCQ\x0c\xf3\xfb\xbc.\x95\xd8X*\x15ua\xe1\x1e\x9c\xa9\
#\x0b7\xe02\xcc\x95\x988\x02\xaa\x18:ua\x01\x15\x89\xd8q\x18~\x0b\x1f\x84\
\x139\xb6\x9cHi\x87\xc3\x01\x13\xd8\x1ey*\xbe!\xbb\x03\x98\xcf\xe7\x00\xaaj\
\xbc\xa9\x1a\xddiL\xb0\xdf\xef\xfbi\xa9\xa6\xa2\xfeCk\xcdv\xdf\xbem\x97\xc32\
+\x7f\x12\x94\xcb\xa3\xf4\xa9\\\x9e\r\xfd\xf9\xe3\xb9\xe1\x0e\xeb\x9b\xf5\
\xee}'K\x16M\x9aLF\x92\x19\x91A3\x144W\xe7\xab\xcd\xfd\xa6\x03P%\x8b*\xa9D3\
\x1c4Y\x8c\x8a(\xd2\x11\x154U\x82\xd11 \x07iPT\xa8\x89\x8dDDc \x08\x06\x82\
\x03\xa3\x82E\x0eDG\xc7#V\xd7\x9c\xbd\x86RR(\xc9\x0c\x89JR!\x91\x192%-/\xf4\
\xb4A\xff|\xc0\xd9\xa5\xfcB\x90EV\x1c\x1f9\xf2(D(\xdbU\xde\x02\xdd\xc0@a\xb1\
(\x12J\x88 \x1b\t\t#K\xc8\x1c\xdb@;\x00\x9e4~\xdb?\x11\x80/<\xd0e\x86\xc7\
\xf1\xa9\x8f\x00\x00\x00\x00IEND\xaeB`\x82" 

def getBGBitmap():
    return BitmapFromImage(getBGImage())

def getBGImage():
    stream = cStringIO.StringIO(getBGData())
    return ImageFromStream(stream)

index.append('BG')
catalog['BG'] = ImageClass()
catalog['BG'].getData = getBGData
catalog['BG'].getImage = getBGImage
catalog['BG'].getBitmap = getBGBitmap


#----------------------------------------------------------------------
def getBHData():
    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"IDAT(\x91]\x91=n\xc2@\x10\x85\x9f\x91[\x174\xb1\x94\x88\x1b@\x93\
\xdc\x86\x9b\xd0\x91\x94!H\xa4AJ\x8a\xe4\x0e4\xdc\x81\xa4\x83\x0b\xd0P\xd8\n\
\x89L\x10\xce\xce\xec\xbc\x14\xeb\x1f\xc1\xd3h5+}\xda7\xb3/*\x8a\x02\xb5\x92\
\xe5\xd2\x86Cx\x1f\xae\x06\x18\xa0u\x13**\x8a"I\x92@\xd0<\xf2\x1co\xef\xccrx\
\xa5*T\xedt\xa2\x08U)\xf2\xbbX\xc4\x15J\x02\xc0z\x83\xd7\x17~\xed\xe1\x1cEB\
\xd9\xf1H\xe7(\x12\xf5z\x06tZ\x1a\xc0`\xc0\xfb\x07\xa4i \xe8\x84\xce\xb5%b@l\
f\xcd\x0e\\\xaf1y\xe2\xcfw\xf5\xbc\x13JKC\x04\xc1!\x98\x90d\xbf\xcf\xe7\x19o\
\xaek\xc8\x9d9\xa8\x1a\x1074\x00~~\xe0q\xc2\xfd\x9e\xe2\xaayD\x1a\x87H\xc4\
\x80\x8e\x99\xb1\x16n\xef8\x9b1\xbd\xe2\x9f\xbb\xa0\xa1JUmv\xa8\xf6^\xad8\
\x9dr\xb7k\xe9p\xaa@}\xc8\'\xca\xb2\xac\xdb\xedV#y\x8f\xed\x96\xe31\x0f\x07\
\xd4\x7foeI\xef\xe1=\xbc\xcf7\x9b\x98dY\x96\xc1\xc7\xe6s\x1b\x8dp\x1em\x93t\
\xd0?w\xebTm\xac\xf7k\x18\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBHBitmap():
    return BitmapFromImage(getBHImage())

def getBHImage():
    stream = cStringIO.StringIO(getBHData())
    return ImageFromStream(stream)

index.append('BH')
catalog['BH'] = ImageClass()
catalog['BH'].getData = getBHData
catalog['BH'].getImage = getBHImage
catalog['BH'].getBitmap = getBHBitmap


#----------------------------------------------------------------------
def getBIData():
    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\xffIDAT(\x915\xc9MH\x93q\x1c\x07\xf0\xef\xf3l\xc9|\x1e\xf7\xc2\xd6\
\xdc\xcah\x8e,\x1b-j\xec\x90\x82t\x88^<F\xa7.\xa5DV\xa3K\xd1)\xe8\x9ab\x87\
\x16Dt\xe9T\x92Ao \xd8I\x10)2!\x8a\xa4\xa9\x18\xb66R\xc2\xad={k\x9b\xff\xe7\
\xf7\xff\xff:D\xb7\x0f|4\xced \x8c\x95\xbe\x1e\xb5%\x9d\xa1\x90"RD\x10B\xb5Z\
\xc4\xac\x00\x05\xb4\x00\x00\xf1\xe9y\xe5\xacj\x07&\xa3_\xcf~\x07\xd0XX\xa8\
\xcf\xcc8\x82AHI\xb5\x1a\x88\xe0r\xb1\x94v>o\x9e\x1a4O\x1cg\xe6\xf6\xd1v\x87\
>P\xd1\xdc\x86\xbf#\x1c\xee\x8e\x9b\xc9\xfe\xf2\xab\xe7T,\x06\xce\r\xbb\xe2\
\x07\xabo\xa6E.\x17\x1e\xbb\xbb-\xb67\xd3Z\xbd\xf5\xf1\xe6\xe2\xf4\xa2\xd3\
\xef\xf1y\xda|\x0f\xbe\xa4\x13\x9d\xc9\xe1\xe8Px|\x9c\x99\x8b\xa5\xbc\xb0)\
\x94N333\xdf[IOe\xa7\xfaB\xfd\xf0A\'\xa5\x00\x84:v,\x153\xa9\xf9+en2\xb3*XZ\
\xf173\xd7Y\x9c\x99=\xfdv\xfd]\xb7/\xca\x1a\xa3\x05\xbd\xa1Z\x92\xa5bi\xb8LA\
\xe2[e\x99k"\xd0\x13\x0f\xf6&\xb8\xda\\\xab\xadV\x9a5\xaf\xe9\xb5%\x91"(\xe8\
\xbf\\\xa4X\x12S\xf9\x8f\xd5T\xcd=\xeeC?^<*e\x97\xac\x8d\xec\xda\xe3\xfbQ3&\
\x9d\xa2P.\x90\xb2\xa5\x92\xe8\x80.\x95\xb4%\xe5\xac\\\x97\xbb\xeb\xc9\xc0\
\x84\x87y\xf7\xf9\xcb\xbe\xc8~o8\x12M\xdd0\x98g\x8e\xcd\xf6\xfa\xf7\xad\x14\
\x97m\x12Pp\xa2\x84\x8d\xfa\xfaH<u\xc4\x9bd\xc5?/\x8d@\xd3\xfc\xd7\xaf1k\x85\
\xd1\xdb\xc2*E\x9e\xbd\x1e=<6\x17y\x9f\xfe|\x07\x9b\xd0\xf0\x10\xf6E\x9b\x99\
\x1b\xf3\x1f\xac\xa7\x13\x8e\xc0vHiW*\xca\xb6u\xc3`\xa2\xad|\xce?t\xc1\x1c<\
\t\xc0s\xd5\xa3\xcde\xe7v\x95;?%bU\xa0\r @\x01\x04\x08@\xfd\xf7\xbf::\xf9ri\
\xe7\xe6_}h&tLr\xcb)\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBIBitmap():
    return BitmapFromImage(getBIImage())

def getBIImage():
    stream = cStringIO.StringIO(getBIData())
    return ImageFromStream(stream)

index.append('BI')
catalog['BI'] = ImageClass()
catalog['BI'].getData = getBIData
catalog['BI'].getImage = getBIImage
catalog['BI'].getBitmap = getBIBitmap


#----------------------------------------------------------------------
def getBLANKData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
\x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x00\x19IDAT(\x91cddbf\xa0\x040Q\xa4{\xd4\x80Q\x03\xa8e\x00\x0028\x00\x1c\
\xbe#|\xfc\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBLANKBitmap():
    return BitmapFromImage(getBLANKImage())

def getBLANKImage():
    stream = cStringIO.StringIO(getBLANKData())
    return ImageFromStream(stream)

index.append('BLANK')
catalog['BLANK'] = ImageClass()
catalog['BLANK'].getData = getBLANKData
catalog['BLANK'].getImage = getBLANKImage
catalog['BLANK'].getBitmap = getBLANKBitmap


#----------------------------------------------------------------------
def getBNData():
    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\xc3IDAT(\x91-\xcc1hSa\x14\xc5\xf1\xf3}\xef\xa5>\x93\x18\rv\x88\xc1\
\xa1\x90\x08\x0e\x8aT\xc9\x92\x0e\xa2\x8b\xa0\x9b\x8b\xa0\xe0"\x1dD\x04\x89\
\x14\xd4]h\'q\xe8\xe0((\xc1Yp\xb2\x9b\x8bh\xc1(\xa2Qi\x13)\tV\xdb\xe4\xbd4y/\
\xdf\xbd\xb9\xd7!=\xd3o9\x7f3l\x02\x0e\xb0\x98N\x04\x90}\x08\x03\x02\x91}\
\xb3@\x04FU\x01L\x06/\xc0\x7fEz\x90\x89\xaa\xc00\x0c\x0b3\xc0\x10V%QV\xe5\
\xdd\xaf\xaf\xfci\xd8fo\x00\xb0\x80L\xb6%|:\xde\xdbvQt0\xef\x84\x08\x86DI\
\xc5\x99\xd4qax\xe9 \xa8.,Lo\xaajL\xc6\x04\x176v\xce\xd2;\x97-\xb5`Td$L"\xce\
\xdaC\xc3\xee\x0f\xef\xed\xdaZ\x1c\xc7\xf5z}\xb6Xt\xcc\xf9\\n\x12\xc7\xee\
\xf9\x13\rw\xe9\xf4\xb3\x99\xc25?{\xd3f.j\xb2\x0e\x83~\xbbi\x00\xd4j\xf7\xdb\
\xed\x1633\xf1J\xf5\xa4\xe7\xf9\xd1\xe5\xeb\xe5\xa3\xf9\xe8\xe5\xaa\xb8q\xa1\
\xf6XUU\xd5X\x1b\xf6\xfbf\xf0\r\xe6\xc8\x83_?7\x1f.GLL\xe4\xaf\x9e/\xddy\xf3\
>\xedh\xe5\xd2\x99\xde\xd5\xdb\xa9L\xe6\xd4\xdc\x9c\xaaZk{\xbd\x9e\t\xbf (.\
\t\xb5L*\x19\x0f\xa8\xfb[\xc3\x7f\x98\xfdTB\xb2\xb7\xf4\xfa\xfb\xfa\xe8\x8fs\
\x8e\x88\xce\xcd\xcf\xdfZ\\\xacT*&l\xe0\xc0\xb1{B-H\x02\x8f\x14.\t\x85bV\xe5\
\xce&\xae\xdc\xed\x90s\xcc\xc4<)\x97\xcb\x8dF\xc3\x17\x86*\x1b\xaf \x9a(\xb3\
\x82\x83\xc3dg&\x10:Q\xa5\xe6\xc7\xdc8\x92\xad\x0eou\xf9\xd1\xf2\x10\x80\xd9\
\xf9\x00a\x88\x80\xdd>\x84a}8\x86\x8c\x00\x81M\x83\x03@ \x8c\x8d\xcf\xf8\x0f\
f^,\xf4\xbdI\x03\r\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBNBitmap():
    return BitmapFromImage(getBNImage())

def getBNImage():
    stream = cStringIO.StringIO(getBNData())
    return ImageFromStream(stream)

index.append('BN')
catalog['BN'] = ImageClass()
catalog['BN'].getData = getBNData
catalog['BN'].getImage = getBNImage
catalog['BN'].getBitmap = getBNBitmap


#----------------------------------------------------------------------
def getBOData():
    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\x1cIDAT(\x91mQ=\xaa\x14a\x10\xac\xd9\xfd4\xf2\x99\xa9\x0b\x06\x82\
\xe01\xbc\x87\xb1\xb9x\t\x11C1\xf3\x0e&\x1e\xc2{\x18\x8b\x81,o\x1f\xe3W\x7f\
\x063+\x066ES\xd5\xddtA\xf7\xd2GG\\#2&\x10`E\x8a\xe0?\x18\x00\xf0\xe1\x13\
\x80\xa6K\x8c\xa4\x0e\xec%>\xda\x07\xb1r\xad\xca5o\xdf\x7f\x1c\x00P\xf4\xe7\
\x0f\xd8H*ao\xbbb\xa5\x8a%+.\x8fO\x01\xc6\xdd+\xdf\x7f1\xf3dE\xd4\xb8v\xc3F\
\xb0j\xd6\xac\x15\xb3\xe6\xe1\xe1\xdd\xf9\x19\xc6\xedk\xdc<]\xcdK+\xd4\x8dZ6\
L\xff\x126l\xe6\xe1\xde\xcd\xafw\x18\x08\x1a\xb7j\x85\xb8e\xc2\xeeC\nf\xc3\
\x86\x89\x0eQ\x82\x11\xa1`+\x84\xadru\xd8wo&a\xa3\xc2\x12\xc6\x17\xe1\xa5y\
\xd1\xef\x84)\x13z#\xa5\xb3\xcbF\xae\x1e\x1c\xd7\xcf+\xc6\x9b3\xde\xf2\xf2}\
\x9e\x19*b83Y\xeed+\x96\x8a\x9f\xe3\xf2\xed\x8c\x01A\xd1i\x9cT1r41\x15m\xd8N\
\xeb\xd8\xb5a\x08\x0b\xbe\x02\x01\xf4\x0f69\xaf\xbf\xdd\x8a\xd8\xf3\x1f\xad#\
|\xb7\xb6e\x1c\x8d\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBOBitmap():
    return BitmapFromImage(getBOImage())

def getBOImage():
    stream = cStringIO.StringIO(getBOData())
    return ImageFromStream(stream)

index.append('BO')
catalog['BO'] = ImageClass()
catalog['BO'].getData = getBOData
catalog['BO'].getImage = getBOImage
catalog['BO'].getBitmap = getBOBitmap


#----------------------------------------------------------------------
def getBRData():
    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\xadIDAT(\x91M\x91;h\x93a\x14\x86\xdf\xfe\xf9B\xad(!\x83\x12\xdb\x82\
C\x15\xc1[\x06G\x15\x94\n"\xe2\xe0%\xa0\xc4IQ!\x93C]\n\nE\xb1\xe0\xa2\xb4\
\xde@\x1c\xc4\xcb\xd0\n*\xd6\xc1E\xcd\xa6.\xb68\x08\x0eR\x15\xbc\x10,M\x9b_\
\xe2w\xdes\x8eC\x94\xe4\xe1px\xe1\xe5p\x86\xa7\x0b\xc7\xd1\xc6\x00\xfe\xdf\
\x11\x88\x1d\xa15M\x04\x00#\xe5\x11\x07\xdc\xcd\xcc\xd4UM\xb7\xad\xff\x1d\
\xc0\xa9w\t\x8djJ\x8a\x18Ee\xe2\xecD\x00\xe0\xf0o\x0b\xdf\xb5\xd5\x19\xef\
\x1cL\xdd{\xdce\xb0\xf0k\xef\xddL\xa4P%j\xec\xcf\xf5\xff\xfb\xe0\xeej\xa4q\
\xcf\xa6\xb4\xd4\xab\xc3\xc3c\xd3V\x10\xfa@\xf3\xc7\xd3\x8b\x87\x1e|\x95\xeb\
\xd5\x0cU\x84\x82\x88\x04\x06\x1a5Io\xedOK\x03\x9c\xfeP:R)\xdc\x1c\xfaS)\xd5\
g\xbaW\x9e\xb90txM\xac\x1e\xabG\x8a\x98\xa0\x89\x04Do\xaey{\x9f$.\x0e\xb9\
\xfc|\xf0\xf4\r\xbf\xfa$\xcb\xb8\xe4\xfc\t\xcfo,\xbaG\xf7\xf8\xe6\xd4|\xb1\
\xaf\x81\x14\t"f\xe7\x92\x93\xcf\xe8\x88\xeeqK\xfe\xad\xd0g>\xf9\xe8d\x98\
\xafyq\xf9\xeb\xd6\xc1\xae{\xf1\xd5{A\x0e\t\x08\x92s\x0b\xc9\x81\xfba\xeas\
\xac\x1c\x1d]\xbb\x98\xd6~\xba,z\xf5Qc\xf7\xf6s\x8fg\xe3\x86\xb1\xec\x97Z6\
\xbb4\x8b:\x02"\xe8\x14\x15Q\x19\x7f\x99\xb9\xd4\x93\xbe\xb8\xb2\xc3\xa5\xcf\
E\xbc\xfb\xe3\xe6\xf1 \x16\xa8B%\x8d\x00\x02"\x84,,[E\x151!W\x94\'\xa5\xbc\
\xb5\x91\tv\xed\xe1\xba\xd5y\xaa)Uibj\x00\xba\xb0\xb3m\xb1\xd3h\xdb\xb4\xa2\
\x93\xbf\xf2C/A9\xd1-\x1e\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBRBitmap():
    return BitmapFromImage(getBRImage())

def getBRImage():
    stream = cStringIO.StringIO(getBRData())
    return ImageFromStream(stream)

index.append('BR')
catalog['BR'] = ImageClass()
catalog['BR'].getData = getBRData
catalog['BR'].getImage = getBRImage
catalog['BR'].getBitmap = getBRBitmap


#----------------------------------------------------------------------
def getBTData():
    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\x9eIDAT(\x91m\xca\xbfo\xccq\x1c\xc7\xf1\xe7\xf7{\x9f\xbb\xf6\xd2\
\xf6\x82\xdc\xc5\x8f\x94F%\xc2\xc0\x1f\xe0\x0f`\xb2\x18\r\x06\t\xe9\x1f \x16\
\x9300u\xa2\x0cX\xbb i\x84\xc9 \x06\x83\x10\x8b\x81\xa4\x069\x894\xbd\xeb]\
\xaf\xe7\xbe\xfd|\xde\x9f\xf7\xcb b\xf1\xc8s|\x16\x93\xb7\x04\xc3\xf9\xcbq\
\x07#4\xf0\x12\xaf\xf0\x88\x837\xf0\x80? \x04#\x1c\xbf\x01\x08G\x8eg\x91\xc1\
\xd4XT\xb4\x10?\xab\xb0L*\xa2\xe9U\xday\xba\x16<\x00R\xfc\x812\x9e\xa5\x04Y\
\xcd\x13\xbeo\xa9\xaa\x14\xabq\xd9\xbb6\xea\xc6\xce\xea\x97\xda\xb1\xc3^\xa7\
\x04\x84\xfe\xdd\x9e\x15\xa2\xb6?\x0e\x06\xa3\x98r\xddc\xd1^\xdeZ\xfbY\xec\
\x89\x9aJ\x9e(q\xf0\x8c\x9b\x94\x90\xa9\x8c\xbfF\xe5\xc6\xe4\x90\x0f_\x0f\
\xc7\xf1\xfd\xf3\x95\xef\x9b[\x9d\xcb\xb7\xb4\x13\x95\x13\x10pP\x96\x92d\x14\
\xa6*ugV\x89\x93Z]\xa1\xa6S\xe7\xafB9\xf7\xe8\x92\x9a\x89d\x0e\xc1\r\xc9\xe4\
\xa6"R\xb3\xde\xde\xeb>\xa9\xf67\x06\xb9J\xfdIs.m\xd8\xcb\x9b\x1aD\xcd\xa4"\
\'\x87\xd2\x1dyR-Nf/\xac\x87\xbb\xfd\xcdv3o\xa7^\xb7u\xef\xe2\xc2\x87g\xe3\
\xb9\xf9\xfe\xd9;\x1a%\xcc\x94\xcd\xa0\xf4\x085\xd3\xf4\xc9\xfe\xf0\xf4\xf4\
\xb7\xed\xc5\x87W\x8a\xe9\xe6\xf0\xcdc\xb1\xabO+\xed\xdbg\x8e\xdc?\xa7v\x94%\
y\x06B9\x8bJ\xd3\xbb\xde\xc1\xf5e\xa6\xb2\x8e\xce\xb7\xbe\xbe\xa87bq`\x812\
\xd12\xdcP&g<;\x14\xa3\'\xb0\x84\xef\xe2\x1d<\x82\xe1c\x9c\xff\xf4\xc7o\x85!\
#\xea\x19>\xf5\x97\x00\x00\x00\x00IEND\xaeB`\x82' 

def getBTBitmap():
    return BitmapFromImage(getBTImage())

def getBTImage():
    stream = cStringIO.StringIO(getBTData())
    return ImageFromStream(stream)

index.append('BT')
catalog['BT'] = ImageClass()
catalog['BT'].getData = getBTData
catalog['BT'].getImage = getBTImage
catalog['BT'].getBitmap = getBTBitmap


#----------------------------------------------------------------------
def getBWData():
    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\x0eIDAT(\x91}Q\xb1J\xa3a\x10\x9c\x8d?\x8a`\x08\x9c\xa0\x9d\x81\x03\
\xf1\r\xf3\x04b\xe9\x8b\xdc\x03\xd8\xd8\xa4S\x1f!M X\x1d\x17\xb8\x80B\xd8\
\x9do\xc6\xe23!w\x88S\xcc.\xec\xee\xb0\xcc\xc4\xf5\xb3\xff\x12\x1d\x94R\xa0\
\x90\x82%H\xa0@a\xdf\x03\xc3\x9f\xc4\xddO\x18\x10lG\x13\x04\xd0\x96\x82>j\
\x1e5\x9br\xc9\xcd\xbe\x7fz\x1bF\x80\x8c\xdf\xe5fH\xa0\xdd\x0c\xca\xb4;\x97\
\\2\xe5\xcb\x93\x00\x15\x9b\xcdf<\x1e\xf7\x97lw\xfe\x12\x11\xb1\\.\x03\xc0l6\
[\xadV$Y,VGfUe\xeeJUM\xa7\xd3\xf9|>\x00 [U\xed\x0f\xfa\xf8\x9f\xf5\xcc\xbe\
\x00`\x00\xd0\x1aIf\xe5N?3\xebP{/\x01 \xd6\xeb\xf5d2\xf9\xfe\xfb>\x8d\x88\
\xc5b1\x9c\xbf\x9c\xdd\xde\xe0u\xeb\x12\x0e=\xe9L\xb9\xba]\xc2\xd5)~=\xfe\
\x18@\xc9\xa3\x8b\xe3n%\x9aA\xa1\x14\xbdiB3\x9a\xa3\xc9\x02@\x05\x1e\xde\xb1\
=\x08\x95\xf8\x8c6\xff\xcbX p\x8c\x0fgu}a\xae\xcd\x92\xb9\x00\x00\x00\x00IEN\
D\xaeB`\x82' 

def getBWBitmap():
    return BitmapFromImage(getBWImage())

def getBWImage():
    stream = cStringIO.StringIO(getBWData())
    return ImageFromStream(stream)

index.append('BW')
catalog['BW'] = ImageClass()
catalog['BW'].getData = getBWData
catalog['BW'].getImage = getBWImage
catalog['BW'].getBitmap = getBWBitmap


#----------------------------------------------------------------------
def getBYData():
    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\x01LIDAT(\x91M\x8e\xb1jTa\x10\x85\xbf\xbd{\xb1\xddj\t[\xa4\xf1\x1d\xf2\
\x12\x16\xe2\x0b\x84`\xaa4a\x1b+\xb1\xd3\xd8\xa4\x8b\x16>E0A\x10RX\xda\xf8\
\x10\x11,D\x16\x91\xbdw\xaf\xee\x9d3\xf3\x8f\xc5\xbd\xc9f8\x1c\x0e\xcc|\xc3!\
\xbb.\x8f\x8e\xf2\xf66!\x1eH\xd0\xc3?\xe8\xa0\x855\xfc\x81\xdf0I\xa0\xef9;K\
\x89R\x88H\x0f\xc2\xd3\x1d\xf7\x94\xf2\x81o\xae\xafk\xd6knnr\xb9d\xb9$"\xa5\
\xc1G\x99R\x96f)M\xf6\xf7\x0b\xd4\xccf\xb9\xd9pz\xba\xbb6K\xf7\xf1T\x96\xa6\
\x01@*P\x95\xd5\x8a\xab+\xce\xcfSB>\xec\xd2lTo\xbb,\x015\xf39]\x97\xc7\xc7#\
\xe0\xe3\xbf\x11\xbb\x87%\xdc\x0bT\xacVyy\x99\x17\xef\xee\n\xdcy\xdf\xef\xdc\
,\xcd\x86Juy\xf2,\xbf|\xeeN\x9e\x1f\x9e\xb8\x8aYHa\nY\x91\x8a)da\x1eR\xf1\
\xc73\xff\xfa\x96\xaa|\xfaX\xde\xbc\xde~x\xdfN\xad\x9d\xaa\x9dZ3\xaao*[W\xd6\
L\xad\xa9\xad\xad\xd5U\xc1#\xea\xb27g\xd3T\xaf^,\x9e.\xbc\x84\x87T\xa4"/\xae\
\x90\x17\xf7\xf4\x88\x88\x8c\xc8`\xcb\xa4\xfb\xf9\xeb\xefb\xef\xfb\x8fo\x07/\
\x0f00pv\x010\xd8Ba\x98\xffo7u\x96\x0c\xc3,\x8e\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getBYBitmap():
    return BitmapFromImage(getBYImage())

def getBYImage():
    stream = cStringIO.StringIO(getBYData())
    return ImageFromStream(stream)

index.append('BY')
catalog['BY'] = ImageClass()
catalog['BY'].getData = getBYData
catalog['BY'].getImage = getBYImage
catalog['BY'].getBitmap = getBYBitmap


#----------------------------------------------------------------------
def getBZData():
    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\xa4IDAT(\x91U\x91\xbfk\x93a\x14\x85\xcf\xfb\xf5k\x92j\xdaDM$BB\xb1\
\xa5:(\x82\x14\\\xfcA'Aqtprr\xf6_pp\x11\x04\xf1?p\x13\xc7\xee\x82P\xed(\x05+\
:\xd9\x82\xb6\xd6\xd8\xb4I\x93&\xe9\x97\xf7\x9e{\xafC(\xd4\x873\x1dx\xa6'\
\x8c\xf0\x1f\x04\x08d\x00\x80\xdc\xf1i\xc7\x03\x100\xbb\xf1\xe2\xd9Y\x00\x06\
7\xc5(_\xc8\x0f\x86\xa7\x0bQ\x8c\x9d\xded\x7fb*\xb4\xbbT\x08\x9d\xb47/\xbf\
\xa6\xa8\xd4\xb2S\xb9\x9d\xb6\xab:\r\t\xb1t\xa7u\xbe\x9ee\xaa[\xcd\xf8~\xf9J\
\xb7[\x12\xba\xd0\xeb\xd5\x04\xb8\x94\x00p\x03\xd5\xc5\x90\x04}\xf4x\xf5\xee\
\xe5\xe9\xc5\xa4q\xc3j\x0f\x1a\x95'OWr\x93\xa3H\x8dT\xa1\x021\x01As*\x94>w\
\xa1Y\xcf\x97\x8b\xdd\xb0\xfe\xfd\xd3\xda\x97\x8f\xfekT\x0b\xc5\xab\xd76\xa3\
\x84(&t\xc0\x12\xd0\xd4\\\xd5\xa9\xa8_l\x96\xfdL\xaeX\xc9\xb6\xe9[\xcd\xda\
\xec\\\x19\xd5\xda\xfc\x1fQ\x8bt\xd1\xb1\x10M\x15\xa2\x1e\xd5\x9a\xdb\xe5C?8\
\xca\x8ez\xf9\xeaO,\xec\xf5\xf6G\x18\xb4\x7fOKt\x11'\r\xb0\x14\x11\xa2.tQ\
\xff\xfc\xad\xbexo\x95Yz\xfb\xfa|T\xdb\xe8\xfc8\x9ci\xad|\xb8\x19\xa9\x91FK\
\x00K\x91\x81\nQDb\xc0\xe4\xf5\xab[\xf7\x1f\xae\xcd\xe4;$\x0e\x10\xde=_\xda\
\xd9\x87\xd0h\x89j\x00\x90bw7\x0c\xcf5\xa6\x9c\x84\xd0\xe3D\xba\xfev\xa1T\
\xea\xab\xe2\xef^\xae\xec^\x9a\xe9\xab\xb9\xa9\xb3\xef\xc0fh\x9d\x089\xce<\
\x04\xfa\x00\x81\x02P8Qz\xcc?(t\x190\xef\xfd\n\xa2\x00\x00\x00\x00IEND\xaeB`\
\x82" 

def getBZBitmap():
    return BitmapFromImage(getBZImage())

def getBZImage():
    stream = cStringIO.StringIO(getBZData())
    return ImageFromStream(stream)

index.append('BZ')
catalog['BZ'] = ImageClass()
catalog['BZ'].getData = getBZData
catalog['BZ'].getImage = getBZImage
catalog['BZ'].getBitmap = getBZBitmap


#----------------------------------------------------------------------
def getCAData():
    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\xa1IDAT(\x91M\x91\xbdn\x13A\x18E\xef\xcc\xcez\xd7?`\xcb\x0e\x16\xa2\
A@\x01\x0f@H\x9d\x9a\x927H\x99\x0e\t\xc9\x12U^\x80\x86\x82\x9f\x12Q\xe7\x05\
\x10o`\x94\xca\x12E\n"\x13RD$\xca\x92\x85\x9d\x99o\xe6\xbb\x14\x96\x10\xa7\
\xba\xc5)\xaetL\xf3\xf4\x99^]Yg\xfd\xf9\xe9p\xb9\xc4\x7f\x90\x04\x10c<\x9b\
\xcdz@\x04\x12\xe0t}\xda_<\x07P\\_\x0e\x06\x03\x92$c\xd3\x18E1\xb9I\xd5\xd2\
\x95\xb7\xf6\xf7]5\xd2\x9c\xbf\xbd~\xe50\xaa\x01\xea\xcf\x8b|y\xbe\xb1\x93\
\xb2}\xf3V}\x1e\xbe|Q\x18C2\x1e\x1fk\x7fb\xef\xdc\x8e\x80CRf\xa5$\xa4D2\xac\
\xbe\x06\x8d\xc5\xc9\x1a\xd1\xff^~q9WO\xb6\xd1u\xd9\xd4\x0c1\x01NcD\xce\x14a\
\x08$\xdbw\xef\xddh`\x86c\x96u\xfe\xf0\xf1\xfa\xfb\xc9\xfc\xf0P\xbb\x00\xd3\
\x99\x18\x12\xe0\xe0\xbdJR\x11\x8dB\x12\x0f\xee\xf2\xe8\x88\xe5\xc8\xb4\xde6\
g\xc5\xc3G\xaa\x9aBg]_\xa3D\xc0&\xef\x99\x84"\x1a<\xc9\xd1\xde\xde\x9f\xd9Vl\
\x1a\x91\xb6\x9d\xce\xc7\x8b\x05I\xf1\x9e!\xe6\xb8\xb9\xd4\xb6\x14\xd1\x104\
\x04UE]\x8f\x0f\x0e\xba\xcf\x9fLUOwvL]\xe7\x9c\x19B.#D\x12\xe0\xd2\xc5\x0f\
\x8a0D\xf5^UI\x9a^\x89\xed\xc7\xb6W\xa3\xaar\xce\xaa\xaa\xbe\xd3^\xb0)E\xc0%\
@\x83\x98\xe9\xc4\xe6\xce\x18\xb3\x89UM\xb7\x0c\xa9\x80\xb5\xd6\x18S\xde\xbb\
_L\xe6*I\x01s\x0c(\x90\x80_\xc0\x8d\xd5\xca{\xff/\xf0f\x88\xc8zw\xb7\x07(\
\x00\xe0/\x16\xb12\xdd\xfc\xf2\xe0\xa8\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCABitmap():
    return BitmapFromImage(getCAImage())

def getCAImage():
    stream = cStringIO.StringIO(getCAData())
    return ImageFromStream(stream)

index.append('CA')
catalog['CA'] = ImageClass()
catalog['CA'].getData = getCAData
catalog['CA'].getImage = getCAImage
catalog['CA'].getBitmap = getCABitmap


#----------------------------------------------------------------------
def getCBData():
    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\x01NIDAT(\x91U\x91/o\xd3q\x1c\x84\xaf\xcd\x8f\xfdIZ\xc9\xc2\xb2t \x088\
\x82!$\x08\xc8\xf4\x02\x82\xf4\x05\xccL\xf1\x0e\x86\xc1\xf1*\xd6\xbd\x04\x12\
4z\x1eO\x05t\xa2\xc8-!t\x9f\xbb\xef\x1d\xa2\xbf\x060\x97G\\\xee\xc43\xc0\xf1\
1\xce\xce\xb0\xb5\x85\xd5\n\x00lH\x00 \xf5l\xf7 a8\x1c\x00x?\x9b\xe1\xe8\xc8\
\xbb\xbb&["\xa0\xd9Jd\x0b\xa0-\x9b\t\x93\xcf\x97\x97\x1d\x00\xcc\xbf]\xcd\
\xe7m:mw\xefq\xc5\x96\xd0`\x9f.\xa7\x1c\xda\x93\xed;\xf0\xa8\x03`\xa7-~\xe8\
\xfc\xfc\xdd\xcb\xe5\x8b\xa7-\xaeD1\xe3Jj\x03\x1c\xf8\xf0z\xf5\xa5\x03\xd0Z\
\x93\xa4\xe5\xf2\xe2\x93\x06\xe0\xf3\'L\xd8\xf7\\\xc9\x1a\x88\x10\xc0\x10\
\x80\xd4H\x92\xfcy\xcd\x8f3~\xbf\xaa\x0c\xabo\x9bi\x1bn\xb2\xb0~\x90\xa4b\
\x8d\x86:\x9dr\xb2_\xa9~\xf5\xdf\x87\x81ia\x08\x80dUi4>}[\xaf\x9eUTi\x9b\xf6\
&a%\xd2\n\x1d\x00I\xdc\xdb\xe3\xc9\xc9\x87\xc9\x83\xfaUe\xd3\xf9\x9b\xb1l9\
\x0f\xb3\xfd\xb5\xbb\xec\x00\xf0\xf0\xfe\xfe\x9b\xd7\x1c\x8fu{\xab\xad\xd0\
\xa6\xad\x84\x1b\x1b-iv\xcbo\xd4\xb2\xc3\xc1\xc1\xc5\xe3GX,ps\xd3\xeb\\{\xad\
\xfa\xcf\xf1\xda\xfd\xce\xce\x1f^/x\xe8m\x93\xb4\xa7\x00\x00\x00\x00IEND\xae\
B`\x82' 

def getCBBitmap():
    return BitmapFromImage(getCBImage())

def getCBImage():
    stream = cStringIO.StringIO(getCBData())
    return ImageFromStream(stream)

index.append('CB')
catalog['CB'] = ImageClass()
catalog['CB'].getData = getCBData
catalog['CB'].getImage = getCBImage
catalog['CB'].getBitmap = getCBBitmap


#----------------------------------------------------------------------
def getCDData():
    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\xa1IDAT(\x91M\x91=h\xd3\x01\x10\xc5/1(6\x16m\xd1\xc6\x14\xfe\n\x82\
\x1f\x84\xe2G\x89\xc1\xe2\xc7\xe4dgg\x1d\\u\x14\x04\x17\x97\x0e\x82\x85\xe2\
\xe0 \xa2\x83\x93\x9bUG\x87\xa2h\rQJ!v(\x19\x92\x1am\xd5\x06A\xd4\xe6\xee\
\xbd\xf7wH*\x8e\xc7\xdd\xe3\xbdw\xbfLrq\xb2u\xfd\xc5\xbe\xdb\x93+\x8b\x15\
\x93\xcce\x809\xcce\xee\xb6\x01K\xdd\xcc\xcd`\xe6f\x9e\xb1\xc3\xb7\x1e\xcd\
\x8c7\xd6\x0bHS1\xa5RH\xa4\xa0\x14\x10\xa8 \x01\x05\x15\xe4\xec\xcd\xbb\xb9\
\xe4h\xf5\xd2\xf1\xee\x9d\xb9\xd2B{\x94RH\x04\x03iH\x01\x06\xe8\xa0C\x01&\
\xbb\xf3f\x9e]Y,?\xfc0\xb1\xd0\x1e\x85\x14\x14AG\x1ad1\xff\xd5\xfb\xd7\xf4\
\x80\x07\x022\xf3l\xa1T\xbd|\xe2Ui\xa4\x05\x12\xa4Ci\xea\x13\xc9\xd2\xd4\xf9\
'\xc9\x8e\xd5n\xd0\xa3/\x0b\xca\xcc\xb3k\xb5\xf1\xfb\xb5S\xef\xdb\xc5\xa0\
\x02\n\xe8\xdc\xfe\xfa\x8d\xb3O\x87\xb7w\xa6/<.\x0c|\xeb\x0bB\x00\xcd<\x9b\
\x1f{}e|nl\xa4\xf9/\xc0\xb3\x8fG>\xfd\x18H\xd5}\xbet\xa8\xb1\xbe\xd3\xd17\t\
\xc8\x0c\xb9_\xf3\xe5{\xef*\xd5V\x1eT\xf4wzP+\xcf7\x93\x03C\xed^\xe9\x00\x01\
Q2\xf3-v\xd2g\xafn\xd4\xbflmv\x067\x7f\xc2\xfa\xea\x9e\xce\xef\xdc\xf2\xf7!\
\x0f\x06\x08\n\xd4\xae\xfc\xb6\xb5\xea\xcb\x9c\xbd\xa9\xcc\xbc=\xfd\xf9\xcf\
\xde\xe20A\x01\x0c(\xd8# \x90`J\x8a\xea9(c\xc7\x0e\xfe\x9cZ\x1e\xbcV\xb0\xc6\
\x99\x1e\xcbM\xae\xf8o\x94\x19\xccdf\x7f\x01\x1d\x0fu\xc7m\x02\x91\xc5\x00\
\x00\x00\x00IEND\xaeB`\x82" 

def getCDBitmap():
    return BitmapFromImage(getCDImage())

def getCDImage():
    stream = cStringIO.StringIO(getCDData())
    return ImageFromStream(stream)

index.append('CD')
catalog['CD'] = ImageClass()
catalog['CD'].getData = getCDData
catalog['CD'].getImage = getCDImage
catalog['CD'].getBitmap = getCDBitmap


#----------------------------------------------------------------------
def getCFData():
    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\x8fIDAT(\x91M\xca?HU\x01\x18\x86\xf1\xf7\xdcs\xecv+\xba\x9e\xc1\xe2\
*\ri\xd2\x14Ak5\xd4\xeaP\xad\xd5\xe4\xe0\xd0?\x97\xbb:D\x93--\xe1\xe4\xec\
\xe0\x92\x10\\]\xb3%\x08\xbaM!\x14(hD\x9bqO\x83\xdf\xf7\xbd\xdf\xdb`A\xbf\
\xed\x81\xa7\xe8\\\xdd)\xbb\xf5\x9b\xa5\xde\x9d\xe7?\xd0\x82g\xb2\xc1\xaf\
\xcf=\x02\xe3\x97\xf61\x96\x08\xc2\x12$,aQ\x95\xdd\xf1\x9d\xb5\x8d\xa9\xa9\
\xa5\xfdkk\xeb\x1f\x1e3\xa1#\x9cz\xf7T\x11/oLx)RLy\x88\xca\xe5g\xdf\xaa$\xb6\
\x86\xf3\xf7:/^\xbf}\x94\x85\xd2\x91\x94vw\xe5\xfe\xfdr\x06\xe5\xa1`z\xe8|]\
\xa0Aqp\xf0srr\x82\x04\x80\xa2\x10\x00@\x9a\x9b\x93\xb9\xb66\xf5O\xa6\x8a\
\xa2\x18\x0e?U\x80\x03(KH\x82 H\x92\xccd\xae\xff\x00\x020\x1a\x8d\xaa\x85\
\xf7\x0b\x8b\xd7\x17\x0f\x8f\x0e)2\xc9V2\xe3\xa1\x99\xdcW\xbf\xaeF2\x8d\x14#\
\xa3n\xd7\xfdA\xbf\x1al\x0ef/\xce\xee5{\x96\x16\x0cOw\xda\x03s\x99\xad|\\1\
\x9a\xd3-\xcd\xe9\xd3\xdd\xe9f\xa3\xa9\x10p\xb9\xd1"\xc3i\x96n4\x99\xcb\xfd\
\xefM\xf3\xca\x03\xc12p\x02U\x7f\x1e\xf7g\xe2\xb7{\xca3\x9d\xb0\x94\xc9\\f\
\xafn9\xd3\x93\x96\xf2\x14\xcf\x8cq\xf9\t\xaa\xbb\'q\xa5\x0e\xa9\'9@\xc9%\
\xc7\x05G\xc4\xed\x9eK!\x85D\x80\x00\xcf\xddD\xb1\xbd\x8dV\x0b\x9d\x0e\xdam\
\x9c>\x0b\x10\x99\xe0\x0c\x12\xc8/\xe0q\x12\x998\xf6\x07\x92\xb1\\\xa0\xd2\
\x03\xbd\x9e\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCFBitmap():
    return BitmapFromImage(getCFImage())

def getCFImage():
    stream = cStringIO.StringIO(getCFData())
    return ImageFromStream(stream)

index.append('CF')
catalog['CF'] = ImageClass()
catalog['CF'].getData = getCFData
catalog['CF'].getImage = getCFImage
catalog['CF'].getBitmap = getCFBitmap


#----------------------------------------------------------------------
def getCHData():
    return \
"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
\x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x00\xb0IDAT(\x91\x85R\xc1\x15\x830\x08\xfdQ\x0f\xbeN`:\x86kd\x8c\x8c\xe1,\
\x1e=zt''h\xfeE\xed!MM\nV.\x10\xe0\xc3\x87`LU\x03\x00\xf6};\xf0G\x98\xd9\x8f\
\xaa6\xc9n\x8a\xacaP\x90\x04H\xb4\x1f\x9b\xe3X\x84\x1b\x01XW \x04`\x9aN\x9fs\
Q[[0\x01\x80J\x14\x08A\x9b\x00$\xd5\x98d\x90wN\xc0y\x8e\x0f\xefE\xbad\xf0\
\x0b\xbe\x91\xb2@\x06\xd0\xc0$\xc5\x0e\xbe#\x10@K\x02\xceE\xf0\xb2\x9cY}\x1f\
\xb5\xb5\xf7\x0c.i_\xf8\xc5\x12\xdb\xae\x8b\x86\xf7g\xb1\xd4Y\xf9\x05\x93.\
\xf1\xb5o\x87\xd6C\xf3=\xb3K|\x03.\x95H\xe5<\x9c\x19h\x00\x00\x00\x00IEND\
\xaeB`\x82" 

def getCHBitmap():
    return BitmapFromImage(getCHImage())

def getCHImage():
    stream = cStringIO.StringIO(getCHData())
    return ImageFromStream(stream)

index.append('CH')
catalog['CH'] = ImageClass()
catalog['CH'].getData = getCHData
catalog['CH'].getImage = getCHImage
catalog['CH'].getBitmap = getCHBitmap


#----------------------------------------------------------------------
def getCLData():
    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\x0bIDAT(\x91u\x8c=JCQ\x10\x85\xbf{\xdf\x13\x13\x8b j\x93\xd2\xacAD\
\\\x8a\x856\x82e\x16`\xe5NR\xb9\x07\x1b[!6\xb6\x82H\x10\xecb~$\x9a\xe4\xce\
\xdc\x19\x8b\x04\xc93\xe6p80\x9c\xefL\xe0\xea\x81oE!\xc2\xcc\xd8\x89\xb9s\n\
\xd8\xbf\x82\x92\x89^\x9f\x1d^\x1c\xefw\x1e\x07Yr\xa3^@\x00\x0f!\x14E\x11c\
\xf4\x15M&\x93\x88qyr\x80s~\xb4\xf7\xf61\x7f\x1f\xcdaY\xaf}\xc7\xcc"p\xfb4\
\xc8\xeew\xcf#Q\xd7\x8co\x96\x99\x95\xd4v\xc7\xbaus?TG\xb7k\x9a\xd3&\x1a\x00\
J^_\xe2g\xbd\x18\xcf,{4K\x8d\xbaO\xa7\x0e\xabo\x97\x83\x18\xad\xdf\x0f\x19h\
\xb7\xbd\xd7sI\x88\xba\x88K\xf2$\x9e\x92K%c\xab5\xecvK\x83 \xe2)\xa1Z\x81\
\xaa4\xaa\xae\xaaP\x1a\x14\xaa.\xc2/\xb4>SA39\xb3\x18DQ\x9aM\x17A3*\x88\x04\
\x11TY\xa4*9/l\x10\xbe\xc0VL\xf5\xfcS\x01?\x86\x8dh\x06\xba\xfb\xef\xab\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getCLBitmap():
    return BitmapFromImage(getCLImage())

def getCLImage():
    stream = cStringIO.StringIO(getCLData())
    return ImageFromStream(stream)

index.append('CL')
catalog['CL'] = ImageClass()
catalog['CL'].getData = getCLData
catalog['CL'].getImage = getCLImage
catalog['CL'].getBitmap = getCLBitmap


#----------------------------------------------------------------------
def getCNData():
    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$IDAT(\x91]\x911JCa\x10\x84'\xc9\x8bb\x11\xb0\x12S\xa4\x10\x04/\xa0G\
\xf0\x18\xe6\x10\x96Zx\x1d\x0b\x91\x98\xc2\xc6RA\xbc\x80\x9e\xc0BE\x10\x13\
\x13\xb33\xbbk\xf1\xbf\x17\x1e\xc2\x16\xc3\xb23\xfb\xb1\xdby\x01\x02\x08\xa0\
\x0b\x00\xd8>\xc6\xfb\x1d\xd04\x05\x00PKW\x01\xec^\x9c\x0fN0\xbb\x8c\xfe^l\
\x1e\xf9\xf6\xab\xcf&\x82)\xa5$CJ\xb2\xe8\xe7\xe9\xb4\n`0\xce\xde\xce\xeb`\
\xec\x9fg\x1e\x0bn\x1cz\xff\x80\xf3\x1b&\x99\xc6\xa4\x85Y\x92\xd5h\xa4\x022\
\xbf\xca\x98\xf9\xcf\xad\xfb/;\x03O\x99\xbf1\x8da\x96\\\x85Y]\xa4\x80\n@|\
\xf9\xc7\xa9\x90\xda:R\xb5\xcf\xe5\x03\x97\xf7\x8cVv\x9a\x05\x99\xc5\x10@\
\xac\xbc\xb0.\x9f\x84-\xce&\x96d\x92%\x15M|H\xb5!])\x81\xe6\x0b}_3i\x85'\xd6\
\xd9\xc5@Fm(-)[\x00\xff\xa7%\xac7@*\x88A\x86Y=\xd1p\xa7Y\x88)Ow\x00\x95\x80\
\xa0z\xc3a\x92]y\x8au|s\xfe\x90\xe0\x1e\xee\xe9.\xa0\xf3\xd8zd[\xa8\xf5\xech\
\xaa\x02\xfe\x00:\xaes0^l*\xa0\x00\x00\x00\x00IEND\xaeB`\x82" 

def getCNBitmap():
    return BitmapFromImage(getCNImage())

def getCNImage():
    stream = cStringIO.StringIO(getCNData())
    return ImageFromStream(stream)

index.append('CN')
catalog['CN'] = ImageClass()
catalog['CN'].getData = getCNData
catalog['CN'].getImage = getCNImage
catalog['CN'].getBitmap = getCNBitmap


#----------------------------------------------------------------------
def getCOData():
    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\x11IDAT(\x91e\x8e\xb1\xae\x8ea\x10\x84\x9f\x8f/G\xa3!"\x14\x12r.@\
\xed\x9e\xb4*7\xa0v)"\xd1k\x84FI\xe3\x88B\xa1R\xfa\xed\xcc;\xa3\xf8\xcf\x9f\
\x1cl&\x93\'\xbb;\x9b\xdd~\xbe!\xe1\xb2BBr\x02\xff\'\xd8\x13n?~\x0e\x94\xd0\
\xd0U\x16qk\xe2\xa2\xc6\x8dZ\xb7\xbax\xfdj\x07\xa0\xd5w\xba\xc8jEW\xa3V\'\
\x9ff\x1am7\x1e\xc4\xec@\xe9\xdf\xdb\xd3\xbaQ3\xed\x9c@D\x1ev\x0c,p7\x83\x8b\
\xba\xa9UQ\xb7i\xa7\xa8L+\x10a\xe3\xd6\xbbg/\x1e~\xfb1^\x95#W\xbe\x84Q\xe4\
\xcc\x91\xbd\x1e\xdd\xbb\xf1\xf6\xe5\xfb\x9d\x036v\xc7=yF\xc7XG\x9d+\x87 ;\
\x07~\x8b_\x83\x85\xcc\x981R\xe5\x8e/;2\xf66\x03\xb0\x7f\xea\x93\xbb\x9f\x9f\
\xea\xe2k5\x19U\xca\x0cR4\x91\x8eoU\xca\xf2\xd9\xf9\xf9G>\xecgp\xdd\x87k\xf7\
\xef\xd4\xeeL}\x1c\xafJG\xc6\xceJ\x97\xbb\x0e7a\xfb\x02\x06` \x10\xf0\x15\
\xffG\xc0\x1f\xb0\x80k\xc1\x03!\x8e\xc7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCOBitmap():
    return BitmapFromImage(getCOImage())

def getCOImage():
    stream = cStringIO.StringIO(getCOData())
    return ImageFromStream(stream)

index.append('CO')
catalog['CO'] = ImageClass()
catalog['CO'].getData = getCOData
catalog['CO'].getImage = getCOImage
catalog['CO'].getBitmap = getCOBitmap


#----------------------------------------------------------------------
def getCRData():
    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$IDAT(\x91eQ1JCQ\x10\x9c\x97\xfc"(\xa87\xf0\x10\x9e@,\xbc\x83\x17\
\xf0\x00Bn\x10R\xab\xd8XX\x04,\xc4Sx\x0b[-\xac\x144\x8a\x92\xdd\x9d\x19\x8b\
\x9fD\xc5a\x18\x18\xd8]\x86\x9d\x86\xed\t\x02KH\x88\x82\x05\xd4/\xc6J\x03P\
\x87\x8d\xd1\xc5\xe5\xa1\x01\x1b\xb2E\x97$\xa9h\xd2\xa4\x92b\xa9\xc4*\x9f\
\x8e/\xda\xc2\x1e\x02\xb0\x01\x18\x80m\xc0\x7f\xd1\xfb\xd6\xda\xeb|\xdea6\
\xc3\xde\x9e\xbf>-\xc3\xb2V\xa4,\xd9\x02i\xd2R\xdb\xd8\x8c\xdb\x9b\xf6\x00\
\xec\x8c\xc7||t\x95\xb2\\\xe9Ld*\xd2\x19\x8apf\xaf\xc3\xdd\xdd\xfb\xbb\xbbN\
\x00\x8a\xceT\x95\xfb\x85\x08g\xae\xe7\x14\xe1\x08e\x0e\xaa\x04t\x02\xc4R\
\x952\x9c\xe5Lg8\xf2\xf7\xed\xa5f\nho\xd3\xc9h\xff@\x1f\xef}\xd0^\xb5\xcam\
\x12\xa4d\x8b\x83\xad\xad\xa7\xf3\xb3\xf6\xb5Xt\xc3\xa1\xa5\xe5\x8bl\xdb\xfa\
\xff%\xa0\xb5\xf6\xfc\xf2\xd2\x80\x93\xc9\xd5\x11K\xa4\x8a*\x8aT\x96(\xb2\\\
\x12)\xc9E\xd9\xbe\x9e\x8e\x1bp\xbcjq]\xe7\xda\xfe\x14\x0c\x14 `\xf0\r2\xf7{\
wG\xf1\xb3\xa7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCRBitmap():
    return BitmapFromImage(getCRImage())

def getCRImage():
    stream = cStringIO.StringIO(getCRData())
    return ImageFromStream(stream)

index.append('CR')
catalog['CR'] = ImageClass()
catalog['CR'].getData = getCRData
catalog['CR'].getImage = getCRImage
catalog['CR'].getBitmap = getCRBitmap


#----------------------------------------------------------------------
def getCZData():
    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;IDAT(\x91u\x91\xbdjTq\x10\xc5\xcf\xde\xfc\th\x14VH\x10\xfc(\xdcR\
\x1bAlW+\x0bA\xb0Hoo\x91\x17\xf1E\x02\x11\xf1V\xbe@\xda\xecF\x10\xc5\x17\x90\
\xb5\x10\x15Rxg\xce9cq\xb3K\x90x\x8a\x99S\xfc\xce\x0c\xc3L\xf0\xea\xe4\xcd\
\xcb\xdd\xd7\xcfv\x01\x00\xb0=\xd6\x8bf#\xda\xed\x86\xcf\xb6\xaf\xdf\xfd\xba\
\xd2\xc3{\xd7\xc6L\x15\x80\xaaM\xbb\xa0\xd5j\xd5u]\xb7S<:=;\xfe\xf2{$6\xd8?\
\xe3\xc7\x85\xcd\x86\\W5\xf4\x9f,{~\x7fZ\xff\xd1y\x80\xb4\xab\\\xb5\xa3\xe1\
\xddGQ~\xfa\xe0\xf2\x0c\x00\x92-h\xdbTIuE\xc3\xe1\x89n~8\x9a\xedm\x97d\xb2$H\
%\x954\x99Nqp\xd0H\xca\x90\x8a\xaa\x94_\x9c\xbe\xbd\xb3x?DV\x842+\xa22\x1dQ\
\x99m6\xfb5\x0cM\xb4\\)S5_\xf6\xf3E\x7f\x0ee"\x02\x99\x15\x81L\x90 \x014\x04\
9\xd2\x8b\xfe\xc9\xb2\xaf\x88q\xde&V\x11f\x82*\x89@C\x98\xaa\xe7\xdf\x8e\x1f\
\xffX\xe2\xd6m3\xbbLd\x9a\xac\xcc\tY\xe4\xd6\xfa\x0c\x00\r\x7f\xf8y\xff\xd1>\
~~\x07\x0c\x18\x00\xc0\xb5\xe7\xf8\xfe\xb5\xe9\x80\xbf3\x19y\x13g\xfcd\xb6\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getCZBitmap():
    return BitmapFromImage(getCZImage())

def getCZImage():
    stream = cStringIO.StringIO(getCZData())
    return ImageFromStream(stream)

index.append('CZ')
catalog['CZ'] = ImageClass()
catalog['CZ'].getData = getCZData
catalog['CZ'].getImage = getCZImage
catalog['CZ'].getBitmap = getCZBitmap


#----------------------------------------------------------------------
def getDEData():
    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\x015IDAT(\x91u\x901\xaa\x14\x01\x10Dkfg\xc1H\x14\x13\x03\x7fj\xa8\xe072\
T\xcc>h\xe8=~\xe0-\xbc\x88\xb0\x970\xd1\xd4\xa3\x082\xdd]\xddU\x06\xb3h\xe4\
\x0b\x8a\xa6\xe0U\xd0\xcb\xdd\xdd;\xcc\x0e\t\xa7\xadZ\xc5\xb6\x08\x08\xffa#\
\xf7\xfb\xfb\xcf\x00$I\x9a\xe9\x99#\xfb\n\xd9\xd3\xdd$y\xb9|\xdd\xd6u\x05\
\xf0\xfd\xc7\xcf&\x8f\xba\xaa*++\xff\x12\x11\x19\xf1\xe1\xe3[\x00\xdb\r\xf0H\
\xba!\xbb\xbb\xab\x9ad&3\xab\x8a\x11\x95\x91\x99\xdc#+\x9f6\x01l\x9f\x98\xb7\
3\xb7\xa4\xab|d\xa63\x15\xa9\x0cg*\xc2{\xaa\xe2\xcc\xde\x80\xcd,\xcf\xa0\xca\
Eg\xb8JW!\x9c\xa9L\xed\xfb\xe1\x9be`3\x80\xe9\x7f\xc3U\x8eP\xc4U\xdbwWN\xa4\
\xab<\x1c`\xe3\x1b\xe0\xb9}\x92G\xa2\xc49\x0e\xb7E\xb91\xb4\x1b\xa2\xfdz\x89\
o\xd8\xfc\x02~&?\x1ei\xa4\xb1F\xd3\x96\xa4>\xde\xac\xb1%\t~\xb2\xe8=6\x14\
\xdc\xc4\xf9\xd5\x8aZ4V-j\x98\xd6X\xb4\xda\x1e\xbb\xedF\xf5\xfa\x1b\xcb\xe5\
\xcb\xcb\x07\x03\x15|B\xee\x10\xe0\x87X\x03\x1a\xd4\tS\xd0\xe0\xbcB\x01\x9c\
\xf0\xab\xf0\x078 \x87a\xf5\xfb\xbfZ\x00\x00\x00\x00IEND\xaeB`\x82' 

def getDEBitmap():
    return BitmapFromImage(getDEImage())

def getDEImage():
    stream = cStringIO.StringIO(getDEData())
    return ImageFromStream(stream)

index.append('DE')
catalog['DE'] = ImageClass()
catalog['DE'].getData = getDEData
catalog['DE'].getImage = getDEImage
catalog['DE'].getBitmap = getDEBitmap


#----------------------------------------------------------------------
def getDKData():
    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(IDAT(\x91eR;N\x03Q\x0c\x9c\xf7v\x0b\x04\x8aD\x85\x94b\x1bn\xc0A\xe0\
 \xb4\xd0\xe5V)s\x88\\!\x02AA\x04R\x96\x04\xa4xl\x0f\xc5[\x90\x00\xcb\x85e\
\x8f\x7fc\x97\x11HL\x92\xc0yDn\xb7\xbb\xf9<\x81?\xea\x00\x80>\x81\x93\xc5\
\x02\x002\x91YJ\xa9\xb3\xd9\xd9\xfd]~|\xca]$\xdcE\xca=\xc9\x97\xe5\xb2\x07\
\x00(\x9f\x9e\x11\xa1\x08I\x8a\x88\xcdC\x1e\xf6"e\x14MfI\xd6a\xc8\xd6\x01\
\xa9\tM\x02\x90\x94\xb4lP\x9a\x8ci&\xb2\x906%D\xc8]\xee\xa0KR\xad\xda\xefa\
\x04Mf"a\x06Rd\x02%"J)\x92$\xb5\xf2\xcaT3~K\xa9u\xdc\xedz\xfc\xc4 \x08-\xef?\
ZR\x912\xb3\xdfv\xdd\xec\xf666\x1b\xb9\xcb\xect\xb5\xd28\x1e\xaeor\xff\xde\
\xe6i\x0b\xc8\xbd\xbf\xbc|Z\xaf{\x00\x8d>\x91 \xa7fv\xc4\xf189\xcd\xe4\x84\
\x07"&\x96D\xaf\xf3\xb9Hy\x00@\xd7\xd5a\xc0\xe1P\x1a\xfd\xee5\x02\x11\x19\
\x01\xa0<\x03\xfe}H\x07.\xde\xde\xfc\xf1\xf1\xf5\xea\xea\xc7\xd9\xfe\xa0\x9d\
\xb9\x02_\x06\xaeY\xf5\xbd\xb5\x05\x04\x00\x00\x00\x00IEND\xaeB`\x82' 

def getDKBitmap():
    return BitmapFromImage(getDKImage())

def getDKImage():
    stream = cStringIO.StringIO(getDKData())
    return ImageFromStream(stream)

index.append('DK')
catalog['DK'] = ImageClass()
catalog['DK'].getData = getDKData
catalog['DK'].getImage = getDKImage
catalog['DK'].getBitmap = getDKBitmap


#----------------------------------------------------------------------
def getDOData():
    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\x017IDAT(\x91uQ1j\x94a\x14\x9c\xef\xdf\x1f\x8b\x15\x84\x10\x8c,\x98"\
\x8d\xe2\x01\xbc\x8d\x85M\xeaTv9\x83\x85\'\x10\x82\x17H\x97\xde\x0b\xa4\x88\
\xddJjAY\xbb\xe4\xcd\xbc\x19\x8b\x7f#\xb1p\x8a\xe1\xf1\x98y\x03\xf3\xc6\xea\
\xcd\x05\x1e\xd02\xca\xb0\x7f~{\xffL\xbb\xef\x07\x87\x06\x0c\xe8\x11\xcf\x00\
>\x9d\xbf\r\x90\xc0\x1d;\xb2\xd7O0\xe6\xf5\xf3\xd3\xd3\x90\x91BZ\n\xb9\xbd\
\xbc\x9c\x01$\xf8\xf1\xeb\xae\x17u\xbb;\x9d\xccnn\xb7)\x86\xe5\xaa\x90\xab\
\xe3c\x03s\x1b\t\xba\xd3N\xb7\xd5\x91\xec$q\xaa\xc2r1U&\'R\xc0\x0cY~Pko\x98G\
2\xadR\xe5*\x93\xa9\niR\xc0\xe8\xee1F\x92$\x00\xf2\x7f\x8ci\xfa\xbd\xdb\x8d-\
pxv\xa6\xdb\xdb\xb0B\x99\x0c\xeb\xe0\xea\xaa\xa7\xf9\xdd\x87\xaf\x92\xa9\x96\
L\xf9\xe5\x8b\xa7_>~\x9e\x0cd\x1f*W\xa5*\xf7\x95\xfb\xbb\xea,j\xca\x94\xa5\
\xee6\xa0\xd9\xc0\xbe8rq\xba*\x89\x93\xe2\xfe\xb6\xba\xd5i\xff5P\xd3f3\xc8\
\xa8-\x0erL\xabi\x8c\xcd\xd1\xba\xdbKu\xb6\xd5\x01<n\xfe}\xe4\xc2\xafn\xaew\
\xeb\xa3\xd7\'\xe7\x8f\xd6\xcb\x80?\xc4\xb2w\xdfN\xf3\x0b&\x00\x00\x00\x00IE\
ND\xaeB`\x82' 

def getDOBitmap():
    return BitmapFromImage(getDOImage())

def getDOImage():
    stream = cStringIO.StringIO(getDOData())
    return ImageFromStream(stream)

index.append('DO')
catalog['DO'] = ImageClass()
catalog['DO'].getData = getDOData
catalog['DO'].getImage = getDOImage
catalog['DO'].getBitmap = getDOBitmap


#----------------------------------------------------------------------
def getDZData():
    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\x99IDAT(\x91M\x8f=kTQ\x10\x86\xdfs\xce\xdd\xbb\xbb\x97\x15\xa3d\r\
\x9b\xb0\x85\x04\x14\xc9?\xd0:\x88\xe8Bl\xf4\x07\xd8\xd8XX\x1aAl\x04\xfd\x01\
\xd6\xda\x88M,C\x1a\xb1\xd1F\xb0\x10;EA\xb6\xca\xfa\x955\xaew\xcf\x99\xafcq\
\x17u\x8aa\x8a\xe7\x9d\x99\xc7\x9d\xbc5\x9a\xc6\x19\x00\x00$\x12\x894\xceBY}\
\xba\xb3S\x86\x16\x80\x9c\xb3\x99\x99\x99\x88\x98Y\xf1\xad\x9e\xde\xdf\xba\
\x91\x01\xcb\xa6\xa6\xa2*"V\x84\xfe`\xd0\x86G\xce\x96\xff\xd5x<.\n_d\xe4\xc9\
\xe1\x0fQ\x15\x152a\xa6\xf5\x9f$\xab\xefm0\xb0V\xcbl\x11\xa9\xaa*\xe7\\\xc0\
\xccr\x16UVa\x95\xe1\xaf\xfa\xf2\xc7\xaf]J5\xef\xf5\xce\x8f\xd0\xef#\x84\xbf\
\x17\xcc\xccG!Q!\x15\x16\xa6,\x9b\x9f\xbfW\x94\xee\x9e9\x11.\x8cf\xbb\xcf\
\x9c\xf7\x8d^\x13\x10\x11\x1f\x89D\x95\x85\x92r"Z\xfe=\x7f\'\xb4\xdf)\xe6\
\xf7n\xa77\xaf\'\xd7\xaex\xefC\x08\xce\xb9F\xddg\x8a\xac\x92\x84\x13SR\x9e\
\x18\x9f\xda\x9f\x96\x07\xd3\xf6\xcd\xedr\xfd\xf4\xea\xa3\x9d\x86\x0e!,^B\
\xacI\x85\x98\x13SJ\xf1\xe9Jg\xde\xc2\x83W\x1f\xf8\xc9\xe3\xa3[W3\x91\x99\
\x01p\xce\x01PU\x8fX\xb3p\x12JL\x91\xd2\xdb.\xaeo,=\\\xebU\x9b\x97\xf2ph\x9d\
\xce\xff\xc6\x00\n\xc4C\x12^\xee-\x9121\'aj\xa7\xf1Ji\xe7\xce\xe6\xec\x1c\
\xd0\xacoh3s\xb8x\x0c_\x0e\x10\x81\x1a\x8b>\x03J\xbcx\xfe\xf2x\xf7H\x03\xa9j\
3\x00\xf8\x030\xe7M\xc9\xeb\xfd~\xae\x00\x00\x00\x00IEND\xaeB`\x82' 

def getDZBitmap():
    return BitmapFromImage(getDZImage())

def getDZImage():
    stream = cStringIO.StringIO(getDZData())
    return ImageFromStream(stream)

index.append('DZ')
catalog['DZ'] = ImageClass()
catalog['DZ'].getData = getDZData
catalog['DZ'].getImage = getDZImage
catalog['DZ'].getBitmap = getDZBitmap


#----------------------------------------------------------------------
def getECData():
    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*IDAT(\x91m\x8e=J\x9da\x10\x85\xcf\xa7\xaf W\t\x88!\x11+\xb9M\x9a\
\xec \xab\xc9\x02l\xc4\xdaJ\xd2\xa4uC. \xd8\xaa\x95"61\x89\x17\xa3\xa2\xef\
\x9c\x1f\x8b\xcf+\n\x0e\x87\xe1p\xe6af\x86\xc7\x93/\xf0\r\xc6\xb2\xed\x0e\
\xd3\xe8v7c\x03\x86\r\x136\x004\xf8\xdf\xe2\xa7}\x00\x80\x90,D\x88\x13\x8dB\
\x98\x10a\xec\x84\xb3\xe3\x9f\rh@\xc0\xab9\xe1\x84\tc&\x84\x19T\\1\x87\xa5\
\xcf\xeeh0\x00\xbfK\xc7\x95\x10\xa9\x98I\xc1\xa4\xd1\xda\xe4fX|D\x1e^\x1e\
\x98\xeb\x99\x1b\xd7\'5\xb4\xfb\xe5\t\xda\xc7\xdd\xbd\x1f\xdf\xbf\xfd\xbe\
\xbe\xa5"\x8b2eJEQ.I\x14\xe9\x927\xd6W\x0f\xb6/\xda\xf5\xe9\xe6\xe5\xec\xc3\
\xc5\x9fVr\xc9\xa4\x8b\xeet\xc9E\x153\x0f\xf5_\x13`\xda\xf0`j\x1c\xbb\xf8b4\
\x9a\xcep<EK\x06<\x1c\x01\x9b;;\xfd\xec,U\xaez\xee\xbd\xbb\xca\xe4\x98\x84\
\x15ji:\xfdux\xd8\xb6\x80\xe5\xbb\x19\xd6V\xc2Ji$\xc0J1\xac\x88!CA\xca\xed\
\xdf\xaf\xc0p\x0e\x10\xf0[\xf1\x95\xc1+\xb3\x00<\x01\xfcl\x81#D\xaf\xf8n\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getECBitmap():
    return BitmapFromImage(getECImage())

def getECImage():
    stream = cStringIO.StringIO(getECData())
    return ImageFromStream(stream)

index.append('EC')
catalog['EC'] = ImageClass()
catalog['EC'].getData = getECData
catalog['EC'].getImage = getECImage
catalog['EC'].getBitmap = getECBitmap


#----------------------------------------------------------------------
def getEEData():
    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\x00\xf2IDAT(\x91\x85\x911JCQ\x10E\xcf\x83\x07.\xc0"\x95X\xb9\x04\x17 \
\xae\xc7\xd6\xc6]\xb9\x81 \xb8\x80,!\x04S\xdb\x86\x99;w,\xbe\xf9\xc6B<\xcd\
\x1bx\xe7^\x18f\xf0\xb8e\xc5\x10FF&D\x980\'\x11"\xc4\xc9\xa4&\xf0\xf2t\x07\
\xd8\xb8\xbb\xdc2e\xabZe\x15YV9\xddY\xfd\xfa\xf4>\x97\xea\x8f\xcf,w\xb9\xb3\
\\\xd5Y\xce\xea\x94\xb3:\xe4(g\xfa\xe6\xfa\n416\xe5\x96\xad\xea\xaa\x8e\xb2\
\xaas\xf1\xe4P\x87\x9cv\x96A\x93\xedC\xdd?\xebp\x90\xa4T*\x17"23\xe2\xfcdf\
\xde\xde\xc2\xdb\x04\xa4\xca\xcc5\xf0\xfd}\xa9G,\x020\x81*I\x8a\x8cs\x7fD\
\xe4e\xf7Z\x01\x8c\xe3\xf1\xb8\xd9l\xba\x1b\xe8\xbf\x01\xc6\x18\xbb\xddn\xda\
^\xd4\x7f\x03\x80\xedi{\xb5\xd7\x03\x8e1\xf8\xc5\x80\xfe\t\xec\xf7{\xdb\x18c\
I\xb6\xed\xefaY\xd4g\x80/\xd4.~\xec\x91&]\x97\x00\x00\x00\x00IEND\xaeB`\x82'\
 

def getEEBitmap():
    return BitmapFromImage(getEEImage())

def getEEImage():
    stream = cStringIO.StringIO(getEEData())
    return ImageFromStream(stream)

index.append('EE')
catalog['EE'] = ImageClass()
catalog['EE'].getData = getEEData
catalog['EE'].getImage = getEEImage
catalog['EE'].getBitmap = getEEBitmap


#----------------------------------------------------------------------
def getEGData():
    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#IDAT(\x91\x9d\x8f!NCa\x10\x84\xe7\x7f<P$\xa8R*p5`\xaa\x90\x1c\x82;\
\x90\xfa:\x12,\xa9@r\x00\x1c\x17\xa8Ar\x86^\xa0\nH\xa0\xc1T\x10\xfa\xcf\xec\
\x0e\xe2\x15\x02H\xbel&\x93\xc9\xec&[\xde\x80\xc4\x86\xfc\xad\xdf\xa3\x1fa\
\x9b\xc0\xee\xe5%\x00g"\xd3\x11V8d\t\x92IKIZ\x02\xf9<\x9b\xb5\x00\x0c\xc7\
\xe3\x13"\x1c\x01\xd2\x11&M&\xe9J\xb3f\xad \x9b\xc3C\x01\xed\xce\xc9Ist\x8c\
\xde\xfe\xe6|\x04"\xb8\xe6\xd6\xe9{\xf3\xb0\x9d\xac\x96\x1a\xc9R\xe9\xf5v\
\xee\xefKD\x94R\x00\xd8\x86a83>\x96\xb7\xe0\xe3\xf6\xc1\x05\xdc\xfa\x8bR\xca\
j\xb5j\xbaw7\x19l\xbb\xbe\\k\xbd\xcaX\xd7\xe7+\xff\x04\xc8\xcc\xe6O\xdb\xb6-\
\xca\x1f\xdcK\xf3W\xdf\xce\xcc2\x1a\x8d&\x93\xc9r\xb9\x8c\x08I\x92H\x9d\x9f\
\xbd\xda\xba\xb9\xdb\x93\x94\x19\x92"\xa2\xdf\xefO\xa7\xd3\x02`<\x1e/\x16\
\x0b\x92$k\xad\xb5\xd6\xce\x90\xec\x9cD)\x86\xc3\xe1|>o\x01\x90\x1a\x0c\x06$\
\xa5\x90\xbaEJ\xea\xb4;\xdf\x81\x7f\xf0\t\xfe\xd7NcxZ\xa4\xd1\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getEGBitmap():
    return BitmapFromImage(getEGImage())

def getEGImage():
    stream = cStringIO.StringIO(getEGData())
    return ImageFromStream(stream)

index.append('EG')
catalog['EG'] = ImageClass()
catalog['EG'].getData = getEGData
catalog['EG'].getImage = getEGImage
catalog['EG'].getBitmap = getEGBitmap


#----------------------------------------------------------------------
def getESData():
    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\x1fIDAT(\x91}\x91\xadN\\Q\x14\x85\xbfs\xe7\xb6\x08B%\t\x02\x05H\x10\
\xf5\x18\x9e\x01Y\x8d\xe8+L&\xc1cx\x16lUU-\x83gT+\x9a0\xc9\x84\xce\x94\xb9g\
\xff,\xc4\xbd\x13:\t\xe9\xce\xca\x97%\xf6^b\xed"\xde&\xb7\xfd\xbb*\x02\xc6c@\
\x99d\x12!\x0f\xc2\xe5\x8e\xbb\xcc\xf4\x0f\x97ww-\x00\xd2\xcf_D\x10!\xb3\x9e\
\x83\xaa\xc9\xaaj\x95Y9<Lh\tT\x04\x01\xf1w\x91/\x0b\xed\xed\xd7\xd1\x8eK&U\
\xa9\x0e&\x8db\xf9L\x93\x00\x01\xbe\\y\xdc\xc2M\xbbz\xbaXwu\xb3\xbd\x11U\x18\
\xd0\x00\x10\x92\x8d\xee\xbf\xf8o/_\'\x1f\x1e\x8f\xbay\xd9\x8a\x1fn<\x93\x06\
\x90\\\xf2\xf6\xec\xe4\xcfIr=\x19\x9d~n\xf5Q\xea\xa4\xbaa\x95*\xb2L\x9aL\xfa\
\x98\x1f\x8f\x0f\xbb\xe7u}\xd9}\x9f~[\x7fZm\xb2\x07\x82K\xeeN\xe9`tu\x95\xb3\
\x19C-C\'\x03{\xe3\x86G9>\x9eO\xa7mBc\xce\xc1\x81\xcc\xf0\xc0\r\xb3b\x86;=\
\xdd\xfb\xc6\x89H(\xab\xedG\xfe\xe7\xc7\xfd\xbc\x02v\xb4J\xaf\x8f\xc6\r\xe6\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getESBitmap():
    return BitmapFromImage(getESImage())

def getESImage():
    stream = cStringIO.StringIO(getESData())
    return ImageFromStream(stream)

index.append('ES')
catalog['ES'] = ImageClass()
catalog['ES'].getData = getESData
catalog['ES'].getImage = getESImage
catalog['ES'].getBitmap = getESBitmap


#----------------------------------------------------------------------
def getESPERANTOData():
    return \
'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
\x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x00\xbbIDAT(\x91\xcd\xcc\xb1\n\x82P\x18\x86\xe1\xf7\xc8!\x84h;\xb8\xd5\x18N\
\x0e98\xb9G\xa3W\xe05x\x05]\x84\x83\x9bS]\x83\x108\xd6\xec\x12\xb5\x05\xd1f5\
Td\x19\xd8\xea\x10XN}\xe3\xcf\xff\xbc"\x9c\x85\x0f\xcb\xb4dUU\x08!\x00\x98.\
\xa7\xb7t\x9f>i\xda\x9e\x8b\xb4LK\xba#W\x8b\xb71\xfe\xd0G\x08\x81q6zt\x1a9\
\x00\x1a@\xb4\x8e\x08V\x01\xde\xc2#/\xf2\xefd=0\xee\x8fq\x0c\x07[\xd9(]\xfd\
\x14\x90\x00JW$\x93\x84ky\xfd\t\x03\xc8(\x8b\xee\x83\xd7\xa0[?f\xc7\xec\xfb\
\xc0|3/(\xe96\xbf~\x9e\xd6\x16\xfeO@\xb2\xe3D\xc9\xa3\x95>p{\x03\xe8\x982\
\xccS\xd0\x19\xaa\x00\x00\x00\x00IEND\xaeB`\x82' 

def getESPERANTOBitmap():
    return BitmapFromImage(getESPERANTOImage())

def getESPERANTOImage():
    stream = cStringIO.StringIO(getESPERANTOData())
    return ImageFromStream(stream)

index.append('ESPERANTO')
catalog['ESPERANTO'] = ImageClass()
catalog['ESPERANTO'].getData = getESPERANTOData
catalog['ESPERANTO'].getImage = getESPERANTOImage
catalog['ESPERANTO'].getBitmap = getESPERANTOBitmap


#----------------------------------------------------------------------
def getETData():
    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\x84IDAT(\x91]\x8b\xb1k\x93a\x18\xc4\xef\xfd\xf2\x19+\x16\r\xb4J\x1a\
\x08\xb1\x9d\x84n\x8e\x0e\x1d\xfc\x0f\n]\xea\xe4\xe2"\xb88\x88\xa0\xb848\x0b\
.nNN\xd9Dpv\x15q*(Xj\tJ\xc1\x04Sc\x92~y\xefy\x9es\xa8\x8az\xfc\x86\xfbq\\\
\xc2\xf6*&c\x9c$\x0c\xd9\x10\x19\x990\xc0\x80\n\xc8@\xfe]\x16Pb\xfc\xed\xfe\
\xcdG\x00"\x14r\x8f\xb0p\xb7l\xe1\x162w\xba\x9b\x1b\xc3\xe9|q\xfbq\x89\xaa\
\x0e\xa6\xcf\xa3\x81\x87{\x04#{\xb2T\xb6\xe81\x9d\xee\xb1b6d#\xc9\xf6r\x13@\
\x89\xb5\xc1rc\xcebf\xe1\x116\'\xce]\xbcS\xab\xd5=bRU\x87\xfd\x07RE\xa7\xb95\
\xcf\x9f\xc5\x05$w\xa4t\x17\xe8K\x06\xd9\x93\xb7\xdd\xe1li\xa3\xdd;8\xba\xb4\
;\xb8\xd2\xa8\x1f\xde\xbbzC\xca\x12S\xea\x8c\xc7\xaf\x0b\x00\x80K\x94(p\x9a\
\xeb\x1b\xed\xde\xc1\xd1\xaaE\\\xeb<\x1f\x1e7\xa4\xfc\x0bX\x04\n\x00\x92I&d)\
\xa7\xa2z\xb5\xbf\x15\xca\xad\xc5\x0f/?n\x9f95\xfas\x80\x18\x81D uo\xe9\xcb\
\'\x98\xc9r\x9ecg\xf3\xe9\xf7\xd3\x8b\x0c-\xfc\x18u\x9fm\x95\x9a\x88\x84Yj\
\xaf\r{\xef\xca\x00j}\xd3>A\x8a,s~\xb8s\xfd}s\xdd\xcd/\xef\xbd)8S\xce2\xc2\
\x1c\xc7\x0e\xa0\x0c\xa0\xa0aeE$\xcca,\xc8u~\x15L\x9d\x96\xcc`\x06\xf7\x13\
\x02HS \xfe\x02\xff\xea\x7f\x13\x80\x9f!\n=\xa6\x88\x1e\x1d\xea\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getETBitmap():
    return BitmapFromImage(getETImage())

def getETImage():
    stream = cStringIO.StringIO(getETData())
    return ImageFromStream(stream)

index.append('ET')
catalog['ET'] = ImageClass()
catalog['ET'].getData = getETData
catalog['ET'].getImage = getETImage
catalog['ET'].getBitmap = getETBitmap


#----------------------------------------------------------------------
def getFIData():
    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\x017IDAT(\x91m\x91\xbdj\x94a\x10\x85\xcf|~\xa2\x84\x15\x14\x02\n\t\x16\
\x92"V\n\xb6\x96^G\xaeB\xd2j#\xf1JR\x08\xd6\x16\x06\xc4J;+\x05\xd1\x904\x11$\
\x01C\xb2E\xf2\xbeg\x9eI\xb1\xcb\xe2\x8a\x0fS\xcd\xcf\x813\'\x8e\x8e\xcf5gX{\
\xf6Y\rM\x86\xaf\xbb\x8fWn\xcaH\xcc1\x00\xa7g\xd3q\x90\xee\xadN$U\xd5\xab\
\xedM\x8aLm>\xb8]U\xb3\xe6\xdf|\xfb\xd9F\xa4\xd9@\xd2\xaf\x93K\xa3L\xea\x7fD\
D3#(\x99\x8b\xf5T\x82]\tUK\xf2*\x14\xd1L\xe8\xc9\xc7\x9d\xe7\x1bG\'-\x93\xd6\
\xcbY=)h.\xbbz\xd2:6-Y_\xbd\xf1\xe6\xe5\xfbQ\x17n\xe6\xb2\x93YN\xba\xcb\x89M\
\xcf\xea\xa6\x19wZ\xd2{5#]\x8c\xc2UU\x14\xd0]6\xcd\x00\x99\x95\tI\x02\t\x14 \
\x11?\x0e\xfe\xdc_\xbf\x05Ti\xeb\xf5~7\xdd\xbc}\xb1\xc1\xb2sI\x11\xf1\xe9\
\xcb\xe18\x8c\\\x0bEH\xa1\xd9v7U%\xfdS\x92\x04m\x14,^~\xf7\xceu\'\xb6"BK\xc4\
\xe2&\xbe\xef\xff^\x04\xf9\xe8\xe1\x9e\xd4\xa4\xe1\xdd\x87\xa7\x93\x15\x19d\
\xbcH\x1b\x9dM\xa7W\xd3th\xf7\xea\xb0\xa3\xa0\x00\x00\x00\x00IEND\xaeB`\x82'\
 

def getFIBitmap():
    return BitmapFromImage(getFIImage())

def getFIImage():
    stream = cStringIO.StringIO(getFIData())
    return ImageFromStream(stream)

index.append('FI')
catalog['FI'] = ImageClass()
catalog['FI'].getData = getFIData
catalog['FI'].getImage = getFIImage
catalog['FI'].getBitmap = getFIBitmap


#----------------------------------------------------------------------
def getFJData():
    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\xccIDAT(\x91M\x91?h\x93a\x18\xc4\xefM\xbe\xb41%\xd6h\x12\xdb\xb4\
\xc5j\xb1h\x87\xd2V\x1d\\\\*B\x9d\xdaA\xaa\x83\x83\x93\x14Q\x91\x0e\x82\x15\
\x8a\xe8\xe6"\x0e\x05\x17\x15\x07EA\xa7X\x10\xaa\xa0\xb4\x82CA\xc1\xb8Y\xed\
\xd2\xa4(\x8d&5\t\xdf\xfb<\xcf9\x04\xfflw\xc3\xc1\xef\xee\xdc\xd2\xf9\x99\
\x8507{\xe7\xd3\xec\x8e\xf7\x89\x96\xc8\xe5b\xf7\xd9\xce\xca\xf8\xf8\xc1\xb1\
\xcaU\xe4\x0cbh\x18\xc4`\x86\x9aA\xe0\x86{.>\x7f0);s\x8d\xc2G\xd6j\xae#\xd7\
\x9e\xdd6_\xa8\xaf\xa6\x87\x838BP\x8cb\x14\xa5\x18o\xcfm\x06w\xe5\x89+\xf4oy\
\xfb2Z.[\xbd\xde\x92J\xd5\x05\x87\x85\x8b\x07\x86\x90\xa4*\xc5\xe8\x95^\xd9\
\xd1\xe6\x10Z\x90O\x0c\x9d\xe9\xdb\x9f(\xaf\xd5\x85n{&\xde\xd7\xbb\xf1\xa5X\
\xa8\xb6z\xa5*\xa7\xf3\x97b\xf5j\xfa\xa4\x94\xeeyt\xf7\xce\x85\xd3\x91\xb5\
\x91c.\x1e\x7f\xfc9X\xf1m_k\xb1\x87?\xbb"\xbbvo\xb0\xd5+)4/\x99SB\t\xb3\xa7\
\xc5\xbc@\x10\xa4\x07\xf6\xe5K\xc9\xa5H\x7f\xa3\xb3\xcb\x99\xbeZ\x89\xae\xee\
\x1d\x18<$\xbeLS\xe2\xfa\xad\xd8V\x96&\'2\x8f\x9eb$\x82\x13?\x1c\xae\xe9\xcd\
Q\xacU\x9b\xcd\xd0$\x16\xa57\xd6\xc8s/\xae\xf4\x94\nZ\xddd\x10\xfd6x\xe4\xe8\
\xe2T\x80\xd0\x94N\x94b\x10\xa5WzcS\x10l\x9f\xbd\x91igqb,\xfbl\xbeQqx\xf3=\
\x80\x98hT\x94\xfeo\xe0\xcf2!8\xf3\x9a\xc7\xf7p\xd4\xfb\xfb\x1f\xb8\xbc\x0e\
\x84\x08\xd00\x8fH*\tm"\x11\xa2Ps\xa2\x10\x83\x10\xcb%\xbc\xbb\xb0`\xebT\x03\
\xcc\x1c\xa6~A\x0c\xa1!l\xfe\x8a\x7f\xd6\xfe\x13b0\x00\xf8\r\x008F\x8c]\xb5\
\x85\xb4\x00\x00\x00\x00IEND\xaeB`\x82' 

def getFJBitmap():
    return BitmapFromImage(getFJImage())

def getFJImage():
    stream = cStringIO.StringIO(getFJData())
    return ImageFromStream(stream)

index.append('FJ')
catalog['FJ'] = ImageClass()
catalog['FJ'].getData = getFJData
catalog['FJ'].getImage = getFJImage
catalog['FJ'].getBitmap = getFJBitmap


#----------------------------------------------------------------------
def getFOData():
    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\x01BIDAT(\x91m\x91\xbdJ\x03A\x10\xc7g\xb9\x15\x9b\xdc\x15\xe1.\x06\xc9\
\xc5\x0f\x08>\x85\x85\x85\xbe\x81\x85\xef (\xc4\x8f\xdaN[}\x02\x0b\x1f\xc0\
\x07\x10\x11\xb1\xb1M!\x87"g\xd0\x90\x8bB\x8a4ffv\xc6bc\x88&\xbfbXfv\xfe;\
\xfb\x1f3\x18\x0c\xe0\x97\xb0\xde}\xee7\x1a\xf3Y\xbf[\x11\x11\x00\x90),\x00\
\x94J%\x00P\xd5\xe3\xd3$.\x0e\xf6\xcbI\x14E\xaa\xea\x93\x93t:\x1d\xeb\xb5}\
\xb9]0\x7f\xe4oC\xd2Y\x18cF/\xf8\xdb\x04@N\x84\x1d\xf2\x7fa\x8f\x9f\xd0\x86\
\xb5\xee\xd1Y\xdc\xee9fa\xa7@HN\xb7\x0e?\x91\x94X\x90\x95H\x90\x84X\x97\xaa\
\xf6\xee\xe2\xc5d\x00\xc9I\x93\xdfsu\xac\xc4\xca\xa4\x84J$DJ(DB\xe8\x0fs\xf5\
\x95\xd6\xf5\x83]\x0b\x9e\xf6\xca\x95|\xc8\xe8\x94I/\xdb;\xdb\x0bWH\x82\xac\
\xc4#m\x1fW+\xf6\x11Z\xb6\xffU\r\xc3\xd0\x8f\xb8\xd9\xec)\xe2\x10\xe5\xfe<\
\x9e\xfe\x801\xe6uw\xd9z\xbf}\nI\x85\x10g\x99\xe4\xcddf+"c\xcb\x17\xe3 \xf8\
\xae\xa5I`\x8c\x81?\x18\x80Q\x8f)\x8ab\xbc\xc54\xcdoa}\x03n\xb2\xac6\xb9]\
\x10a\x11\xdf\xf0\x03x0_\xe6\x0b~m\xe3\x00\x00\x00\x00IEND\xaeB`\x82' 

def getFOBitmap():
    return BitmapFromImage(getFOImage())

def getFOImage():
    stream = cStringIO.StringIO(getFOData())
    return ImageFromStream(stream)

index.append('FO')
catalog['FO'] = ImageClass()
catalog['FO'].getData = getFOData
catalog['FO'].getImage = getFOImage
catalog['FO'].getBitmap = getFOBitmap


#----------------------------------------------------------------------
def getFRData():
    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<IDAT(\x91m\x91=\x8aTQ\x14\x84\xeb\xbc~\x06#8\x89\x82\xb4f.@p\x03F\
\xc6\x82\x1b111\x1614\x11c\xdd\xd3lA\xcc\x8c\x9cn\xee=\xb7~\x0cz\x04\x03\xbf\
\xa8\x82\x82*\xaa\xea\xdd\xd7\x1b\xfc\xc5\xf4\xdb\xd7\xd7\x92\xe6\x9c\x92HV\
\xd5\xb3W/|\x0bN\x100\xb0\x03x\xf3\xf2\t\x808v\x8e\xc7\x07I\x00$\xb1\x9d\xe4\
\xde\xc7\xcf\xe1rw\xd6\xfa\xf5\xfe\xc3\x0e\x00\xc1\xef\xf3\x92b\xfbt:%\xb9\
\xb8\xabJ\xd2\xf5\xcf\x1f\xee\x99\x9ex\xf8\x88\xc0\x06#\x8e\x14\xd9T\xb6mKRU\
\x17a\xdb=<\xa7\xd7L\xb7\x81\x9d\xb4l\xc9Rh%\xd9\xb6-\xbe\xd4\t\x00\xcf\x99\
\x9e\xeeU\xdd\r\xec\xdd\xb4#y\xd9b\x0e\x87\x83m\x03\xfb\x06\xbb\xaa\xcasf\
\xb5\xbb\x8b4\xb07Me\xc9\x94I\xe7\x1f$%IOu\xa7\xd7vI\x18M\xd9\xa4\x97\xcc%\
\xfb\xae\x8dt\xa7\xd5\x9d\x9e^\x0b\\\x06\xf61Hz\xd1\xa4\x16\xfd\x1f\xe6\x0c\
\x97\xd7*\x8a\xc0~\xee&}\xff\xea \x82\xdc.\xfb\\~\xac\xaa\xaa:<>\x9a,1Z\x06\
\xf6\xf3\x99\x9f\xbe\xdf\x8c\xd1\xe7\xc1\xdb\xd1O\xaf\x8e\xdd\xbd\xc6h\xa9\
\xbb\xc7\x18\xcf\xbf|3\xeen\x06\xf0\x07\xee\xad{fq\xbe!N\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getFRBitmap():
    return BitmapFromImage(getFRImage())

def getFRImage():
    stream = cStringIO.StringIO(getFRData())
    return ImageFromStream(stream)

index.append('FR')
catalog['FR'] = ImageClass()
catalog['FR'].getData = getFRData
catalog['FR'].getImage = getFRImage
catalog['FR'].getBitmap = getFRBitmap


#----------------------------------------------------------------------
def getGBData():
    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\x02\x02IDAT(\x91\x05\xc1[HSa\x00\xc0\xf1\xffw\\\xabV\x94\x87E\x9aF\xa2v\
\x81\xa4\x87(\xa8\x91\x10\xd1\xcd\x11E>D\x99E\t\x15B\x12H \xf4\x10\x96\x96\
\x11]\x9eR)C\xe8\xc1"\xe8\x86\xb3\x0b\xb9.b\xb9\xa02\xcb\xb5(\xa6\xa5Y\x99\
\x8a\xae]\xce\xce\xce\xb6\xef\xeb\xf7\x135\xb5\xed\xee\x82q\xbc\x1e\xe5\xde\
\xdd\x11\x98%\x95Z\xb1\xcc\x91\x7f\xa7N\xe8\xce\xe0\x86\xcaO\x81\x88Bn/J\xa4\
[/\xcd(?\xdc\xd0\xa5Ss\xaa}\xe4\xaf\x94FL\xfa?\xc8D\xf2\xc7o\x195\xa4|\xf7Z~\
\xe9\x8d\xc4\xe4\xe0O)\rS>\xb8)\xc3!\x9f_\xae\xdf\xd6\xa6\xa14\x05o\x83\x0e\
\x91\x9b\':\xda\xf3\x1c\xf1h\\\x88\xfe>\xf1-\x186D\xbe#"\x8eW\x0b\xd7\xc6\
\xa6\xa7\xb3\xe3\x06D\xa5\x86\x00@\xf0fXg\xcbf\xbc\x8f\xb32\xa2\x0c\x0c`\x8e\
\xe5d\x849YC\xc3\x99+\xdd\xce\xd0?,\x0b\xc0\xe6\xd6zr\xb5\xd5\x0b\xedS(\x18Q\
\x14-\xe7B=\xfdA\xfa\x02\xbczO\xd51\x06\xbfV\xcd\x8b1\xd7R\xce\x05v.\xda\x94\
\xef%%n>\x06\x9008\xc4\xd8/&\xc6\tE0\rF\xff\xf0\xbc\x8c\xa4\x89i\x91Jqd\xcf$\
\xd8D\xc1\x12\xf2\x16\xe3\xd0A\xe1r\x91\x99I\xc5\x01"\x11L\x93\x99v\xae\xb7`\
\x18\x98I\x12\x16E\x85\xfa\x8b.\x9bG\xdf\x99/\xb3\x86\x13\xd9\x02\x8a\x0bC\
\xd4\xd7\xd1\xf1\x845+\x99;\x9d\xbb\xcf(+\xe5Z\xf3\xd1[\xd9\xd1\xb8Y\x92a\
\xbf\xcaVM*\x85\x02(^4\xc1\xe9ZN\xd4N&\xec\x18&\xf1T\xcf\xa4\x93\xc6V\xf6\
\xeek\xdc\xe4WV4\x9dN\x81\xa5!AQ\xbc4\xac|\x9d\xea\xec\xf9\xee\x919\xb6iJ\
\x1d,U\xe5;\xb2uu{(K\xde\xf7X>\xef\x8dJ\x93t\x12\x926T\xfa\xfb\xc3\xa6@[\x8b\
VQ}n\xff=\xa6\xd2\xebv\xcd_\xdb\xe9\x05.\xf7\xaeR\xa3\x9f\x9b\x89\x1dr\xf8\'\
\x1eyr\x00\\\xff\x01r\xb4\xfe\xcb\xc7\xdb.\x02\x00\x00\x00\x00IEND\xaeB`\x82\
' 

def getGBBitmap():
    return BitmapFromImage(getGBImage())

def getGBImage():
    stream = cStringIO.StringIO(getGBData())
    return ImageFromStream(stream)

index.append('GB')
catalog['GB'] = ImageClass()
catalog['GB'].getData = getGBData
catalog['GB'].getImage = getGBImage
catalog['GB'].getBitmap = getGBBitmap


#----------------------------------------------------------------------
def getGEData():
    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\xb6IDAT(\x91E\x91Ok\x13Q\x14\xc5\xef{y\x99@\xa9\xb6\r\x01\x8dHW\xba\
\x8e\xb4:\x8b\x82\x7fw.\xfc\x83\xda\x85\xf8\x01\\\xf9\r\x04\xc1U\xa1\x1b\xa1\
 \xf8\r\xdctQ\x05\x03-\xd6E\xd0\x12\x95jq\x1b\xc8"\x8dZ\x12\x13\x9cI2\xf3\
\xe6\xddw\x8f\x8b\x89z\x16\x17.\xf7r\xe0\x9c\x9f\xea\xf5z\xf4W"\x92\xcf\xe0t\
\x95<M:\x1d\x11\x11\x11f\xfew2DT\xa9T0\x1c\xf8\xaf_t\xed\x9cZ(\x03\x94\xad\
\xad\x81\xdd\\\xb5\n\x00\xc3!\xbf{\xab.\x84T=\xd5j\xb5t\xee\xed\xbe\x1d\x0c>\
\x7fp\x07\xfb\x00\x88\xe0\xbfw\xfd\xe1\xd4\xde\xee\x7f:\xda\xad\xdb\xbd\x06\
\x111\x8b!"\x00\xc5\x8bW\xe6\x8f\xcd\x9a\xdar\xbe\x82\x1d\x9c\x03\x00\xc0\\\
\xbeV.\x05&\\\x01 \xc2j\xfc\xe8a\xf1\xf6]\xfc\x8eH+d\x19\xbcG\x92\xf0\xde{8\
\xa7\x97\x96\x11\x94\xe0=\x15\xb4L\xac\x9e?\xfe\xf3\xc9c\x93n\xbc\xd0\xe5\
\x8a?\xec\x80\x19\x8e\xc99\x88\xc7\xcc\x0c<\xf3\xeb-\xa4\t\x1c\x8bsp\xae\xb0\
\xb88\xea\x1c\x19\xf3`U\x9f\x0f\xe9\xccYRJ\xac\x85\xf7H&\xfc\xb1\tf}\xe9*\
\x05\x01\x84\x0bJ\xfb\xd4\xea\x85rP\xdf\xa6n\xb7\xcb\xcc\xce\xb9x\xa7\x9ee\
\x99\xb56M\xd3\xc1\xfd{\xbf\xee\xdc\x18\x8f\xc7\xa3\xd1(\x8e\xe3\x1f\x1b\xeb\
Q\x14\xc5q\xdch4t^p\xfajs\xb8\xfdf\xb2\xf92\x0f\n\xf7?t\xfc\xfcY\x7fw\'Z\x7f\
\n@D\x8c\x88\x00(-\x85s\xfd~)\\\xc9[V\'NRf\x95RD4{k\xd5$I\xf1\xfa\xcd\x1c\
\x9cj\xb7\xdbS\x90BBS\xa8A\xad&D\xa3f\x93\x99\xf3\xbf\\D\xf4\x07\xd2\xb6Ns\
\xf4W\xf2\xc7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getGEBitmap():
    return BitmapFromImage(getGEImage())

def getGEImage():
    stream = cStringIO.StringIO(getGEData())
    return ImageFromStream(stream)

index.append('GE')
catalog['GE'] = ImageClass()
catalog['GE'].getData = getGEData
catalog['GE'].getImage = getGEImage
catalog['GE'].getBitmap = getGEBitmap


#----------------------------------------------------------------------
def getGHData():
    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\x17IDAT(\x91m\x8e=\x8aT\x01\x10\x84\xeb\xe9\x0b\x84\r\x8c\x97eL\xbc\
\x817\xf0\x06\x82\x89\xac\x81\xe0f\x1e\xc0d#O\xa3\x91\xb0\xe39<\x83\x89\x1e@\
Y\xd0\xa9\x9f.\x83\xb7\x83\xb3`S\x14MW}\xd0K\xf1o\xe6\xfe\xfe_-\x05p}\r\xa03\
\x98AR\x07qm\xd8\x95z\xe2\xb7\xfb\xfd\n\x00h\xbf\xff@\x82\xa4\xd2\xe6w\xa2*\
\x96\xac\xb4\xecv\x03\xac\x00:\xbd\xd7&k\xdfU\xc5R\x1b\x00i\x80u\x82e\t\xe0\
\xd6\xa8\x0b\xdd\xfe\xd6\xa7\x8f\xa2ty\xc9\xb3Gl\xd5\xb2\x15\x16\xe1\x17\xb6\
\x97\xd2\xaa5\xe0V7\x9f\xb9\xbf\xd1\xe1\x8f\x96\xf2\xea\xed\xd6\xde\x00\xcf\
\xe0\x01\x80\xd6\xad\x8b-\xe0\xab\x97|r\xc1\xdd\xc5\xe1\xcdk\xb6\x87#@T3X\
\x1f\xbe\xc7\xbb\x17\xfa\xf6\x93\x1e+d\xc4\xa1\x9eK\xd1\xb3/T\xc4P\x91\xc7O\
\x1f\xfb\xeb\x07\xac0\x1c+\xd2h\x8b\x19jtt)\xf4\xc8\x13O@\xac 4>?;W\xe4\x897\
r\xe4\xb1F\x8e]\'I\x93\t\x06\x0b\xae\x00\x02\x06x"\x9f\\|\xd4\x00\xc0_\x862e\
e\xe4:\x93\x12\x00\x00\x00\x00IEND\xaeB`\x82' 

def getGHBitmap():
    return BitmapFromImage(getGHImage())

def getGHImage():
    stream = cStringIO.StringIO(getGHData())
    return ImageFromStream(stream)

index.append('GH')
catalog['GH'] = ImageClass()
catalog['GH'].getData = getGHData
catalog['GH'].getImage = getGHImage
catalog['GH'].getBitmap = getGHBitmap


#----------------------------------------------------------------------
def getGLData():
    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&IDAT(\x91eO\xbbj\x02Q\x10=WW\x0b\x0b\xc1\x85\x04\xac\x02\xfe\x82\
\x8d\x1fbgmko\x9f\xb4\tZ$\x85\x8dZ\xf8\x1b\xa2$6\xd6\xb6"\x16\x8b\xdd\xee\
\xe2\xdb;wN\x8a]\xc4\xc7\xe1\xc003\xe7\xcc\xc3\xc4q\x8c\x1b\xa8\x02P\xbd\x86\
\'x\x00\x8a\xc5"\x00\x92\x00\x10\x86<\x9d\xe0\xfb\xcc\xe5\x92\xe2-\x82 \xf0\
\x92\xc1$\xb1\xdba0\xe0|\x8e\xe3\x91\xbe\xcfF\x83\xb5\xda\xad\xda\x18#"\x99T\
M\xa2\xdf\xe7d\x82\xed\x96\x87\x03W+\xbe\x7fp\xb1x\xd8\xa0\xaa\x99\xf4\xf6 \
\xe0t\n+\xbc\\h-/\x17\xee\xf7\x1c\x8d\x9e\r\xc65\x9b\xa6^g\x14Q\x04\xaatJ\'t\
\xee\x91"\xa6T\x8a\xdbm\x0f\xbd\x1e\x0b\x05\xaa\xf2\xeb\x13\xbc\xffr<f\xab\
\x95.\xb4\xd6T*\x1a\x86\x19\x05h-\x97K\xfc\xfe\xdd\xa9\xad\xe5pxUC\x84"\x02x\
\ndEx>\xa3\xd3\xa1*\xabUf\xb3\xdcl\xd8\xedr6K\rb!\x0e\xce!1d\xac\xa0\\\xa6\
\xb5\xf8\xfe\xc1\xeb\x0b\xf2y\xb3^#\x8a\xf0\xf6\x06\x11\x88\xc0\xb9\x84\n\
\x98=\xa07\xc4}\xfa\xd0\x02\xf0\x0f\x18\x8a[Jp\xcda\xd0\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getGLBitmap():
    return BitmapFromImage(getGLImage())

def getGLImage():
    stream = cStringIO.StringIO(getGLData())
    return ImageFromStream(stream)

index.append('GL')
catalog['GL'] = ImageClass()
catalog['GL'].getData = getGLData
catalog['GL'].getImage = getGLImage
catalog['GL'].getBitmap = getGLBitmap


#----------------------------------------------------------------------
def getGRData():
    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\x01NIDAT(\x91e\x91?K\x03A\x10\xc5\xdf]N4b\xe0\x08\x11\x1b\xd3X\xe9\x81]\
D\xc1B\x10\xc9g\x11\xf1;X\x0b\x16\x16\xe2\xa7\x10D\x05\x8btF\x05\x11\xc5\x14\
\x01I\xc4\xa8\x87H\n\xf1\x0f\x045\xc7\xee{\x16{\x89\x01afx\xb3\x0co\x7f;\xeb\
\xe5\x96\xce\x01\\\xec\x86\x00J\xabo\xa0\xf7\x9dX$DB$&\xad?\x06?DB\xc8\x04\
\x00\x96Ka\x14E\x92V\xe6n!\xedmNK\x10\x00\tr)I\x14\x1e\xe3\x17/\x8e\xe3b\xb1\
(\t\x00\x00I\xe77\xef\x14(\x91\x92D\xa6:;\xe2\x9fV\x9e\x037\xd4\x9f\x06P\xbb\
\xfb\xb6\xa4\xb1\xb2\x96\xc6\xca\x18\x19KZ\xe5\xc3`c\xa7\xee\r/\x9e\x96\xe7\
\xf3\x07[3\x92\x96\xd7\xea\xa4\x8e\xb7\xa3\x94\x02)\x8a\xbb\xc9\xf7\xfdf3\
\x0eL\xd2ct\x0cTy\xbdNGB\xa5!Q\x1a\xcb\x06\xb5\xea\xbd\xd7n\xbf\x16\n\xe1\
\x80\xe1\xa0`?\x01\xf9\xbe\xdfj=\x05\xfb\xd5\xce\xc2l\xe6\xabK\xf5\x9c\xe4\
\xbc{0\x14\x9c\x18\x1d\xc9\x9cU:\xc1\xc9U{j2\xf7\xd1I\xac\x95\xa5\xace_\xd0\
\xb5\xa4\xa5,\x95\xcf\rm\x1e6\xbc\xc6\xc3\xe7x~X\x12\xdc\xfa IH\x1f\xfaG\x08\
\x91\xc2\xe5u\xd3\xc3\xc4Q\xfa\x91]\x02\xe6_\x10p\xe7p\xf5\x17\xeb\x1bkP\xc4\
G\x864\x00\x00\x00\x00IEND\xaeB`\x82' 

def getGRBitmap():
    return BitmapFromImage(getGRImage())

def getGRImage():
    stream = cStringIO.StringIO(getGRData())
    return ImageFromStream(stream)

index.append('GR')
catalog['GR'] = ImageClass()
catalog['GR'].getData = getGRData
catalog['GR'].getImage = getGRImage
catalog['GR'].getBitmap = getGRBitmap


#----------------------------------------------------------------------
def getGTData():
    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\x1bIDAT(\x91e\x8f1jVQ\x14\x84\xbf\x9bw\x8b\xbf\x90` \xc4\xc2\xc22\
\xcb\xb0\xca\x1e,\xec\x93\xca\xde\x15\xb8\x01W\xe0"\xdc\x84k\xb0\xb2\x08\x84\
 I\x88\x8f\xc7\xbdsf,^@\xf0?\xcd\xc0\xe1;3s\xdar\x9d\xda\x000\xac\xfe\xf5\
\xf5\xe1\xd0m\x1b\xb0\xfd\xb4\xfa\xf2\xc3kdd6s\xa0\xd73_>\x02\x943\xd5\xde\
\x9c\x9f-\'@\x92\x00\xa737\x9fbG\x159\xdf>?w:\xc0\xedcTl\xc2\xc9\xb2\xe3I\
\x129?\xefbgV\xde\x9e5\xe4\x8e\xb1#SF\x95\xe4\x1f\xbd\xcfP\xec\xc8Q\xc1\xe6\
\x8e\\n*\xcaQ\xfdO\xc7\x19\x95T\xe4\xcc\x82AGT\xa8\xcat\xa6\x8e\x0e\x92\xa9\
\x97\x1f\xa6\x1a\xe5\x8e\xa8\x17\x83\xcc\xa3\x04;C\xc9^\xc9\x01wd\xa5\xcd\
\xca\x14S\xc7\x01\xd9\x97*\xaa\x02\xea\x0cK\xcbT\xa6\x18u\x84\x93\xa1\x90\
\xc8\xa8\x00:\xab\xa7O.N\x99\x95m\xd0\x1a@\xdb\x05\x96\xc6\xbbsH\xb3S\x01\
\xdc\xb8\xfa\xc3o3\xccjV\xff\xf8~\xf7\xea\x80$\xdb\xb6\xef\x9ft\xf5\xfe\x02\
\x0c\xde-\xfe\x02\xd5\x00s\xcdr\x8cr\x81\x00\x00\x00\x00IEND\xaeB`\x82' 

def getGTBitmap():
    return BitmapFromImage(getGTImage())

def getGTImage():
    stream = cStringIO.StringIO(getGTData())
    return ImageFromStream(stream)

index.append('GT')
catalog['GT'] = ImageClass()
catalog['GT'].getData = getGTData
catalog['GT'].getImage = getGTImage
catalog['GT'].getBitmap = getGTBitmap


#----------------------------------------------------------------------
def getHKData():
    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\x01PIDAT(\x91U\x91\xb1.\x84q\x10\xc4\xe7\xfb\xdfG|\x1c"\xa2P\xd0\xea\
\x14J:\x8fB\xe7\t$<\x85\xc2S\x88\xe2\x94\x1a\x12/\xa1\xe2rDHD\xf8\x8e\xb0\
\xb3\xbb\xa3\xb8#l&\x93-&\x99\xdd\xfc\xaag 1\x9e\xfc\xf1\xbfr\x00\x80\x03\t\
\x14\xa0v\xa0{p\x00\x00\x99\xcaT\x04<\x14\x8e\x08\x91"\xe5\xfe\xeb\x83^\xaf.\
\x00\xa0\xbc\xbbW\x84"@*\xa2\xbb\xb9\xa5\x99\xe9\xb7\x93\x934\x8a&3\x91ee\
\x05@\x01\x80\xd48\x1dQJ)\x9d\x8evw\xb4\xb66\xb5\xb8X\x15\xa4\xd9H"\x1d\xa8\
\x13P\x84\xdc\xe1^UUsx\xa8\x97\x17\xdd\xdcj\xaa\xe9\x1c\x1d\xcd<<\xbc\xef\
\xed\xd9p8:/\x81\x1a\x80<D\xc2=\x19\xba\xbe\xd6\xf6\xb6zgj\x1ae\xe8\xfc<?>\
\xd2\x0c\xa4\xdc\xf3\xa7\xc1\xe1.\x9a\xe8\xaf\xc7\xc7\xb3\x8066\x94\xa9\xe9\
\xa6==e\xdb\x8e\x7f \x1d(\t\x80\x94\x99\xe8i69?\xaf\xf5u\x99\xe9\xf2BM3\xd1\
\xed\x8e\xd2r\xcf\xdf\x06\xb8\x8bLR\xe4\xd7\xe3c\xb5\xbf\xff\xd9\xef[\xdb\
\xce]]\r\x07\x03\x99\xc1\x99\x1e%"G\x1c\x92^-/\x17R\x1er~\x92\xb9\xb4\xd4YX\
\x18>=\xd5\xab\xabp\xcf\x88\x12\xa1\x08\x07\xaa>`\xff\xb9\xfe]\xfc?\xfbI\xe0\
\x1b\xf2\x8b=\xe6c\xc4\xda\x04\x00\x00\x00\x00IEND\xaeB`\x82' 

def getHKBitmap():
    return BitmapFromImage(getHKImage())

def getHKImage():
    stream = cStringIO.StringIO(getHKData())
    return ImageFromStream(stream)

index.append('HK')
catalog['HK'] = ImageClass()
catalog['HK'].getData = getHKData
catalog['HK'].getImage = getHKImage
catalog['HK'].getBitmap = getHKBitmap


#----------------------------------------------------------------------
def getHNData():
    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\x01bIDAT(\x91m\x911k\x14q\x14\xc4g\xe3\x12s^\x1f#\x18E\x08\xd8\xe6\x0b(\
\xc8\x81b:\x05\xbb\xd4~\t\x0b\x11\x8b\x83@P\xb4H\xa1\xd8\x88\xa0B \x9d \xf6\
\x87\xa5\xa5\x8d\x16F.\nZ\x98\xdd\xb0\xfb\x7f\xf3f,\x96\xeb\xf2\xf8\xf1\x98\
\xc7\xf0\x8aa*\\~\x83\x7f\xc40\x14\nA!\x05\xf04P\xe3oy\xb4s\r\x80\x04Y\x99H)\
i\xa6I3\xc5\x14\xa9\xa0\x98~\xb7\xfb\xbaFQ\t\x1d\xfe\xea3\x95\x89\x85\xed\
\xa0\x06JQaF\xd1\xfa\x85\x11\xd0\xd5\xd3\xa7\x9b\xb7o\xac\x9dti;e\xa7\x05[\
\xce\x81pB\x92%\x8dG5\x9b\xeb\x98\xcf\xe7\x92$e\xe6q\x13{o\xbfGD\xdf\x97\xae\
\xef\xbb\xae\x9b\xbe\xf8\xfa\xfb\xcfq\xdb\xb6M\xd3\xb4m;\x9b\xcd\x96\x86\xb4\
\xb6m\x9f]\xc6\x9d\xc9y\xdb\xfb\x9f\x8e\xde\x7f8\xb2\xbd\xbd\xb56Z\xae\x06\
\xd7\x80\xa4%I\x8b\xdb}\xd1\xcb\xfd\x1f\xb6\xefNV\xef\xddZ\xb5\xfd\xea\xe0g\
\xd7\xe7\xc27\xc9\xea\xf1\xf3\xcf[\x93\xab\xed\t%\xa5L\np\xca\x92\x94f\xca\
\x86$\xc9\xe3s\xf5\xf4\xd9\xc7\n\xd8\xbd\xff\xf0\xe6\xb7\xc36B\xc1,t)\x19\
\x91\x85\x8eP\xa1#\xc8\x14\xe9\x8dK\xe3/\x07Oj\x80gj\\\xb98\n\x8a\x14\xe9A\
\x04\xc5\x14\xd3\x99\x1e\x1e,\x03\xa8\x80\x07\xc0\xca\xa2\xc8r\x9a\x18Z\x1f\
\xf6\xca\x7f\xd9\xbdt\xc3\xb4K\xeei\x00\x00\x00\x00IEND\xaeB`\x82' 

def getHNBitmap():
    return BitmapFromImage(getHNImage())

def getHNImage():
    stream = cStringIO.StringIO(getHNData())
    return ImageFromStream(stream)

index.append('HN')
catalog['HN'] = ImageClass()
catalog['HN'].getData = getHNData
catalog['HN'].getImage = getHNImage
catalog['HN'].getBitmap = getHNBitmap


#----------------------------------------------------------------------
def getHRData():
    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\x01lIDAT(\x91m\x911hSq\x18\xc4\xef\xc5T;t\x11Dp\x08\x8a \x94\xee\xed\
\xdc\x0e]\xc4U\x04\x17\x11:\xe9,\x08\x05\x1d\x0b\xa5\x82\xd0\xd9\xc5\xa1\xd8\
\xc9\xb9\x9b\xe0\x92!CG\x07\xb7\xf8\xc8\x98\xe4\xe5\xfd\xdfK\xfe\xdfw\xf79\
\xa4\x8d\x08=\x8e\xe3\x86\xdfMW\x04\xfeI\xff\xf7\x1b]\x04\x80\xc3C\x00!\x01@\
\xa7\x13\n\xd1\x83*,\xc3,\xdc\xe3:\xeb\xf3\xf3.\x00 \xe2O\t\x12d\x98\xbd{~\
\xe2\x0f\xc3\x7f\x87?\xd2\xe9\xfb\xd7a9r\x0e\xb3\xa2\xd7\x13\xd0\x01\x10\x8a\
\x15m\xe4\xf1\xd7\xb7\x9f\xd6\xa7\x9f\xbf\x1c\x9c\xaeO\xcc\x16\x91\xf3\x95\
\xcd\x04\x80\xa4$I$\xe9l\xdb\xd6./\xf3\xde\xdeb0\x98\xef\xecTU\xd54MJ\xa9\
\xae\xeb\x94\xd2h4\xba\x1a\x90twwo\x9a&\xef\xee.\xe9\xb6\xdf\x9fL\xa7Kz6\x9b\
\xd5)\x95e\t\x92K\xda\xdc\xcc,\xa5\xb4\x18\x0c\xe6\xdb\xdbm\xbf\xdflm\x8d\
\xc7\xe3%]UU]\xd7\xc3\xe1\xb0\xc0\x8b\x9fG\xaf\x1e\x97\x93\x851\x9c2j6\xfcu\
\xf6\xfdC\x98={\xfa\xf1\xf6\x83M\xa3\\rF\xef\xee\x9doo~t\x91\xdd%\xa3V\x83[\
\xf7\x9f\xbc<83j\x8d2\xca\\\x1e\xe1\x0c*\x00u\x91\xe5\x8a{\x1bkN\x912\x81\
\x943H\x99\x82\x14#\x9c\xa1\x08W\x00*\xb0\x7f\x01\x17\xe6\x8e\xec\xc8Bv\xcc\
\xafKv\xb8#\x0b\\\x1d\x8d\xbf\x12\xd3w\x1d*\x1e\x9e\xc6\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getHRBitmap():
    return BitmapFromImage(getHRImage())

def getHRImage():
    stream = cStringIO.StringIO(getHRData())
    return ImageFromStream(stream)

index.append('HR')
catalog['HR'] = ImageClass()
catalog['HR'].getData = getHRData
catalog['HR'].getImage = getHRImage
catalog['HR'].getBitmap = getHRBitmap


#----------------------------------------------------------------------
def getHUData():
    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\x00\xecIDAT(\x91}\x8e)RCQ\x10E\xef\xab\xfa8\x14."\x06\x96\xc1"\xd8\x04*\
\n\x9f]e\x1f\xc9\x16b\xc0"\xa2R}\x87F\xfc|f\xb8\xa2\xebt\xd5\xe9a\xec\xf1%\
\x02\x00d\x01-<W\x01\x13\x80\xf5v\x0b\xa0\x93N`C\x8e\x05)R\x93-5\x19)\xe4a\
\xb7\x9b\x00\x00\xcd\xe7\x97\xb6a7\x19\x1bd\xc8&S\x0c\xab\xabB^\xad\xd7\x99/\
t\xfa\xb3\xddU-u1\xac\xb0\xba\x98\xaay\xbe\x80a{\x8c\x01\xa0\xbb\xd1h\xf4_\
\x19c\x9cN\xa7\xf9\xa5\x8b\xf5\x0e\xbf\x06c$\x99>\xa4\xff\xf7w\x8f\xee$\x03\
\x0f\xd8<n\x8e\xafGYt\x95X.\x9a4\xcb\xc5\xa5\x95uws\xbb\x7f:L8C\x12M\xea"\
\x95\xeab\x9be\xd2%S\xb6\xda\x00&\x14\x18\xad\xaeW\x0c%+\xa4\xc9P\x12\x9b\
\xb2\x14Y6l\x1b\xc0\xc0=P@\x01\xe7\x1fP@\xe3[\xde\x00"\xe4m\x06\x8e\x93\xa5\
\x03\x00\x00\x00\x00IEND\xaeB`\x82' 

def getHUBitmap():
    return BitmapFromImage(getHUImage())

def getHUImage():
    stream = cStringIO.StringIO(getHUData())
    return ImageFromStream(stream)

index.append('HU')
catalog['HU'] = ImageClass()
catalog['HU'].getData = getHUData
catalog['HU'].getImage = getHUImage
catalog['HU'].getBitmap = getHUBitmap


#----------------------------------------------------------------------
def getIDData():
    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\x00\xf6IDAT(\x91}\x8e;J\x04Q\x10E\xef\xeb\xee\xc0@a\xc6\xc0@\xb7"\xb8\
\x1aC\xd7a\xe6\x02\x0c\xdd\x8f\xb8\x00\x03C\xcd\x9a\x11\x95\xe1\xd5\xfd\x18\
\xf4\x0c\xa80\x1e*(\xa8{\xaa\xaa\xbd\xacG\xbc\x0b\x00\x00\x0b\x00\x0c\x18\
\x00\xc0}\xef\x1f\xfd\x84Y\xa7w\xb7\x00b\xc3\x8e\x149"\xcc\x94,\x86\x0c+\xc5\
\x90\xcf\xf7\x0f\x13F\x00\xe0\xdb+\xa4H!w\xa5r1Uf\xa5*\xbd\x8f\xe7\x17\x06&\
\x08\x91\x97\xb4\xc9\x90`\x85e2EW\x0f\xcb\xbd\xc2j$\x81\x89\x80\xbf>\xf5\xf1\
\x1e\n\xbb}LuW\x85\xe5\xaaT\xb9w\xb3\xda\xf1I\x07\xa6\xd5\xcd\xf5\xd1\xe5\
\x956\x9bH\xb1\xe2\xe51\xc5\ne1\xcbqi\\\xad\xcf\x9e\x1e\x9b$\x00I\x82 \xc8a\
\x86a\x98\xe7y\xb2\xddZK\xb2\xd3\x0e\xb0LI\x0e\xb6\xff\x8f\xfe\xd1&\xdb\xc30\
,\x0e\xf6\xb4\xd6\xf0\x8b\x06\x04\x80\xed\xc9\xf6v\xbb\xf5\x02\x0c\xc3\x07X\
\xd4o\xffbv\xee\x97/\x0e>\x00\x00\x00\x00IEND\xaeB`\x82' 

def getIDBitmap():
    return BitmapFromImage(getIDImage())

def getIDImage():
    stream = cStringIO.StringIO(getIDData())
    return ImageFromStream(stream)

index.append('ID')
catalog['ID'] = ImageClass()
catalog['ID'].getData = getIDData
catalog['ID'].getImage = getIDImage
catalog['ID'].getBitmap = getIDBitmap


#----------------------------------------------------------------------
def getIEData():
    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\x14IDAT(\x91m\x8f=\x8aTa\x14D\xcf\xf7x\x828L\xe4\xcf0\x83&\x82\x1b\
\x11\x8c\\\x80\x89\xa1\xa9\x99\x820\xabp+&\xb3\x18\x93\t\xec@0\xd2\x16\x1f\
\xdf\xad[e\xd0\x8d\x81=\x87\x1b\xd6)\xea\x0e>\xc3\x06\x80A\xec\xde\xed\x16\
\x16\xc0\x07\xb4=z\xf9\xc2\xc6\x13O|\x9f\x95=\xd7\xaf\xae\x8f\x89\xf8\xe2\
\xf1\xc5\x18\x0b$\t\x10+\x9f\xde&\x15+]\xfb\xf7_VV \xdf~\xef\xda\xdd\xdd{\
\xed\xcf\xef\x9d\xe7\x1f\x7f~\xe5\xfb\xd7d\xa6j<|fX1v\xda-\xb7\xbar\x8afz&E\
\x97a\x05\x9aV$K\xd6I\xdc\xa9\x19\xcf\xb8\xe8\x02V\x84\xdc\xd5\xa5\xbeSH4\
\x93\x19\x15\x92\x0fB[\xb2\xa6\xa7\xfaD\xb0\xd3\xc7I\xe38ITj\xf6T\xabz:\xfe\
\xdf\xa9\x19\x8aVZ:NjU\xd7\xe1\xee\xf8A3\x14n\xdc\xc0\xcaFY\x97g\x97\xd5%\
\xf52\x16`\x8c\xc1\x81e\xe5\xc9sh\xbaq\x1b\x06\x1f\xe1'\x086\xd8\xb8\xf9ps\
\xf5\xe0\xca\xb6$\xdb\xfaq\xfb\xf4\xf5\x1b\x83\x8f\x05\xfc\x05J\xc3r\xa9\x15\
\x84\x03\\\x00\x00\x00\x00IEND\xaeB`\x82" 

def getIEBitmap():
    return BitmapFromImage(getIEImage())

def getIEImage():
    stream = cStringIO.StringIO(getIEData())
    return ImageFromStream(stream)

index.append('IE')
catalog['IE'] = ImageClass()
catalog['IE'].getData = getIEData
catalog['IE'].getImage = getIEImage
catalog['IE'].getBitmap = getIEBitmap


#----------------------------------------------------------------------
def getILData():
    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\rIDAT(\x91m\x91\xb1J\x03Q\x10E\xe7\x85\x04\xc1\xc6n\xb1\x10\xec\xfc\
\tK\x05\xbb\x90\xcaB\xacD\x10A\x02"vi\x04\x1b\x11\x05\xad,\x14\x1b\x05\xed\
\xd2h\xeb_\x84@J\xab\xf7\r;s\x8f\xc5\x86\xdd\x8d:\xd5}\xcc\xb9\xdc\x99y)\xe7\
l\xad\x92$\xa9\x16\x92\xdc\xdd\xcc\xdc\xbdz\xa6\xa5\x9d|?,\xcc,\x00,d\x92\
\x85\x88 d\x1e\xb8\x08\'\x84;\xd7G\xd3\x94s.\x8a\x02\xa8\x12*\xc1\x7f\x95R\
\x9aL&\xdd\x1aj\xd3\xb7/\x08N\xf7\x16\x0c\xd5\x9c\xddj\xe29\x8d=\x7f0\xfdf\
\xa5\xc7j\x87\xe1\x1d\x1bk\x1c\x0f\x1a\x83\xbbwj\x1a\xc0\x18l\xe2%\'\xbb\xf4\
\xfb\x94%\xfb[\x0b\x11\x92:\x92j\x1ax\xff\xa2t\xc6cn^)\x83\xa7\xcf\x16\x0f\
\xee\xde\xad\rU\xcea\x1f\xe0\xea\x91\xe5\x1e\x0fgD\xd0\xee6;\xfc:\xce\xf9A}\
\x99\xc60_z}[\x97\x17\xb8,\x1c\x97\xb9\x9b\x87E$\x0fsY\x84\x85,"\x85\x10\xf6\
6R\x9a\xcdf\xed\x8f\xfc+\xdaef?)\x08y\x12\x05 \xf8T\x00\x00\x00\x00IEND\xaeB\
`\x82' 

def getILBitmap():
    return BitmapFromImage(getILImage())

def getILImage():
    stream = cStringIO.StringIO(getILData())
    return ImageFromStream(stream)

index.append('IL')
catalog['IL'] = ImageClass()
catalog['IL'].getData = getILData
catalog['IL'].getImage = getILImage
catalog['IL'].getBitmap = getILBitmap


#----------------------------------------------------------------------
def getINData():
    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@IDAT(\x91MM\xbdjTa\x10=\xdf\xf5\xa2\x18\x8b\xf8\xb3\xa601\x881 \x16\
\x8a\x82\xaf!>\x82\xe0#XZ\xa5\xcb\x93\x98\xde&`\x93F\xb0\x11;\xab,v[Y\xc8&n\
\xb1w\xce\x8f\xc5\xdd]3\x9c\x19f\xce\x999\xd3r\x86MxL\x03\x86\t\x1b\x1e\x1b\
\xaeG\xa2\x07\x80\xc3\x8f\x00\x02\xb7\x18Q \x98-\xbcfv\xa8\x98q%L\xea\xef\
\xd7\xcf=\x00 \xa9\x19"XI!\x8a+\xa9u\x1d\xe2!\xaev\xe3\xa1\x89\xde;\xaf\xdb\
\xcdg\xe8w\x12\'B4\xfd}\xf7\xfbt_\xd6\xabG\xe7\x87\x93Y\xc2\x98\x0e[\x7f\xdf\
\x0fN[I]k\t\x92\x8c\xdf>\x9d\xfeZ^,^<\xbd\xf7cz\xf9\xee\xcdc\'q\x9ct\xad\xfd\
\x99_t\x1d\x80\x00\xc9\x06\x8b\xc5\xf2`w\xeb\xcb\xd9\xf9\xe5b\x99$NF\t\x80\
\xdd\x8d\xae@\xd0\x02$\xc9\xf3\x83;\xdf~\xcey}\xeb\xe5\x93\xdbIV\xea\nn\xf8\
\x80\xe3\xb7\xc7\xb3\xf9\x8c&U%\x96\x8bb\xa9h\x96\x8a"E\x9a{\xdb{\'G\'=\x88\
\x91\xda\xec\xfd_57\x97\xb4da@\x8f\x014\'\xb7&\xa3\xcd\xaa\x9a4eIb(I\x91,\
\x18\r\xef\x81\x01 0\\\x01\xaf0\\\xc3\x00\xf0\x0f\xfa<M\x16\xb29\x92\xc3\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getINBitmap():
    return BitmapFromImage(getINImage())

def getINImage():
    stream = cStringIO.StringIO(getINData())
    return ImageFromStream(stream)

index.append('IN')
catalog['IN'] = ImageClass()
catalog['IN'].getData = getINData
catalog['IN'].getImage = getINImage
catalog['IN'].getBitmap = getINBitmap


#----------------------------------------------------------------------
def getIQData():
    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\\IDAT(\x91\x9d\x8e\xb1j\x93a\x14\x86\xdfO\x7fl)\xea &!\xd4\x80B\x16\
]\x02\xa5\x1d\xf4\n\xf4\x02\xa4\xeded\xee\x9e\xab(\x1du/B\xc4M\xd4\xe8\x9a\
\xba(-\x01\xc5\x1a\xc1Vl\x9a4\xc9\xf7\x9es^\x87\xdf\xa2B'\x1f^\x1e\x9e\xe5\
\xc0I\xc2\x1f\xe2\xdf\xbepI\x00\xb6\xb6\x00(\x02\x11p\x979\xdcd\x063\x91\xfa\
\xcb\xe3\xdd\xdd\x02\x00 }9\x84;\xdcE\x96\xfe\xbdL1+g\x91\xa9\xd1\x08\xa0\
\xc0\xda\x9a\xee\xdeC\xa5\x06A\x96\xe1!7\xb9d\x94Q\xee\xa2)By\x8eJ%\xba]\xb8\
{D\xcc\xc3\x9e}\xea\x9a\xf9\xcc\xec\x8c\xf9\xe5\xe1\xebW_\xdfLf\xb3\xe3\xe9\
\xe8\xc7\xd9\xc9\xf6\xfb\x9d\xd1x<\x99L\x86\xc3a\xf9\x12^|~\xfe\xe1\xe7\xc7\
\xf1|T]Z\xae.\xdex\xf7\xedmq\xe9\xf2BZ<\x9d\x9f\xee\x1d\xef\x1d\x8c\xf6\x15\
\xdalnDD\x01@\xd2\xa3[\x0f\xb3\xe7\x07\xf5\xfb\xee~\xed\xca\xd5\xd5\xea\x8a\
\x84\xdb\xd7\x1b\x92Vn\xb6\x9e\xec?]\xbf\xf3\x18RD\xa4V\xab\xd5n\xb7\x8f\xbe\
\x1f%%\x92\xe6F2<h\xa4\xd1\xcdiL\x91\xa6\x9c\xd6j\xb5N\xa7S\xf4\xfb\xfd^\xaf\
7\x18\x0cH\x92\xcc9\xe7\x9c\xcb Y\x96\x19\xcd\xbc\xd9l\x02(\x00\x90V\xaf\xd7\
I\x9a\xb9YyH3+mf~\x0e\xfe\x83_x\x8eB~M9z*\x00\x00\x00\x00IEND\xaeB`\x82" 

def getIQBitmap():
    return BitmapFromImage(getIQImage())

def getIQImage():
    stream = cStringIO.StringIO(getIQData())
    return ImageFromStream(stream)

index.append('IQ')
catalog['IQ'] = ImageClass()
catalog['IQ'].getData = getIQData
catalog['IQ'].getImage = getIQImage
catalog['IQ'].getBitmap = getIQBitmap


#----------------------------------------------------------------------
def getIRData():
    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\x01UIDAT(\x91]O\xbbNBQ\x10\x9cs9\x01\x95\x98\xa8\x05\x85\x08\rT\x16\xfa\
\x01\xd6\xfe\x82\x85\x7f@Go\xfc\x07\xec,\x8d\x85\xb1\xb6\xc1XjCALH\xecL\xf0\
\x11\xac\xd4\x10\x11\x82\xf7\xec\xd9\x1d\x0b\x1eA\'\x93\xd9\xd7\xec&\xebp\
\x02\xfc`\n\x03\xe2L\x17\x19f\xea\xe11\xc4\xd1\xfe\x11\x0033\x98\x9aFSe\x8c6\
\xa1\x88\xc6H\x11\x8d\xa2ruz\xe5\xe1\xe1\xe0z\xa37\xa3\xceM\x91\x1aT\xa2J\
\xb0 *A\x83h(\xad\x96\x91\xc07\x0f\x9b\x1b\xd9\x8d\xb5\xecZo\xd4\xdb\\\xd9|\
\xf9~\xd9\xca\x97\x9e\xbe\x9f\xb6V\x8a\xcf\xa3\xd7\xd2r\xb1;\xe8\x96\xf3\xe5\
\xc7\xaf\xc7\xed\xf5\xed\xe1\xc1\xd0\xa9\xaas\x0e\x00I\x10\x049NywK#\xf7\xf6\
\xb8\x94\xe5\x0c\xce\xb9\xc1`\x90L\xbe\x9d\xf6&\xf1\xf2\x82\x1f\xef\xccz\x9e\
\x9fq\x11\x80\x999U\x9d.L\xef\x93\xaal4(\xc2z\x9d\x99\xcc\xdc\x9f$I\xbf\xdf\
\xcf\x1c\xe7r\xa8V\xd9n#\r\xect\x98\xa6\xect\xb8\xb3K\xefi\xc6V\x8bi\xcaV\
\x0b\xe31\x1e\x1e\x867\xd7.\x052\xb5\x9au\xbb\x08\x81"\x14\xe1<Y\xc8\xa1\xea\
*\x95\xcf\xfb{o@\xf2\x93\xa2P\xa0\x08\xa2"\nD\x9c\x08b\xc4Dc\x84*T\x11\x82\
\x01n\x04\xd8\x02\xf1\xb7\xfc7\x02\xf0\x0b\xcf{C\x1ej\x83A\xa2\x00\x00\x00\
\x00IEND\xaeB`\x82' 

def getIRBitmap():
    return BitmapFromImage(getIRImage())

def getIRImage():
    stream = cStringIO.StringIO(getIRData())
    return ImageFromStream(stream)

index.append('IR')
catalog['IR'] = ImageClass()
catalog['IR'].getData = getIRData
catalog['IR'].getImage = getIRImage
catalog['IR'].getBitmap = getIRBitmap


#----------------------------------------------------------------------
def getISData():
    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\x01aIDAT(\x91mQ\xb1j\xd4q\x18\xcb\xef\xfe\x7f\x87\xd6\xa9\xedU\xe1(\xb4\
8\xba\xf8\x00\x05qW7\xc1\x17\xf0\t\\\xbc\x1e\x05\x11\'\x07A\x1c\x047\x11\x07\
q\x13\'\x07\xfb\x08\x0e\xe2&8\xf4\x06\xd1\xb6\x1c\x1c\x14\x8e\xefK\xbe8\x9c\
\xe7\xd4\x0cYB\x12B\x1an\xbc\xc6\n\xfa\xfa\xe0g\xd7]\x93\xba\xbd\x97\x08"\
\x88\x05\x11\x84\x08\x04@ z\x00\xcf\x0e\xf6\x01T\xb9\xb56\x9c\x1c\x00\xed\
\xf0\xc9M\xd1,\x93EY\xa5d\xa5\xea\xcd\xf8]\x0f\x00\xf0\xaf\xb3\x85\xaa\x00\
\xf0\xf8\x18\xf0\xf4\xf7y\xd2\xa9"\x15\xac\x94\xc8\x1am\xad\x01\xecQU\x82\
\xaa$\xdb6\xd3v\xb0H\xa7\x94\xac\xa4\x82%\x892\x10MRk\r\x80m\x18\xa7\xf7\xef\
m\xbe\xff\xe0\x8b\xd0Z\x9b\xcf\xe7\xed\x070\x1c?\xe2tj\xd2\x99\x95\x89LgV\
\x86#+\xb3"\x9c,\xc6\xa5\xdd\xbdo_\x8e\x9a\xa4e\xbca\x18\xa7woo~\xfcta\xc3`0\
\x98\xcdf}\xb7\xf3b\xf2\xf4\xd6\xf4\xcfyRo\xc7\xfb\x15i\xfb\xce\xe4(\xb9\x1c\
P\xc9b\x89\xac\xdd\xab\x97??\x7f\xd5cA\xaa\x96\xb2\xed\x8a\xb0\x9dT\xfc3\x98\
\xd4\xd2@\x01`\x8f\x08\xaa\xael\xac\x91\x02\xd0\x8fF\x00F\xc3u\xaa\x92%Y\x12\
\xab$\xc8\x05TC\xf7\xf8\xff\x91g\xb3\xc3\xef\x1b[\xd7ON\xb6\xb7\x1f\x02\x01\
\xd4\xea\xe0Z1\xfe\x02ZAf\x94h\x00P6\x00\x00\x00\x00IEND\xaeB`\x82' 

def getISBitmap():
    return BitmapFromImage(getISImage())

def getISImage():
    stream = cStringIO.StringIO(getISData())
    return ImageFromStream(stream)

index.append('IS')
catalog['IS'] = ImageClass()
catalog['IS'].getData = getISData
catalog['IS'].getImage = getISImage
catalog['IS'].getBitmap = getISBitmap


#----------------------------------------------------------------------
def getITData():
    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\x00\xe2IDAT(\x91\x85\x91AJ\x03Q\x10D\xdf\xc8\xdfy\x82\x11\x02\x12\xc89\
\xb2\xf2\x16Yy\x077\xe6\x14^%\xf7\xc8\t\xb25\x17\x90\x08\xc3\xef\xeaj\x17##\
\t\xa2\x8f\xa2{S\x0f\x1az\xe0\r&\x00\x0c\xe2\xfc|\xf65\x0f\x9b\x8daI\xe3\xc2\
\xfei\x0f\xd8vy\x1c\xc7*\xa0jY\xbb]E\x94T\x11\x97\xc3\xa1\xd1\x80z\xff<\xa73\
3\x7fz\x0b\xa7S\xf5^\x11\xc3jeh\x18\xbb\xd2)\xa72n\xdbU\xd5\xfb,\x10ah@\x92*\
\xc9\x92u\xdb\xbe\x16\x80\x86\x9032\x94\xff\t\x92g!-Y\xdd]\xf9\x970D\x18\xee\
\x10Q\xd1\xb3+\x15\xd9\x7f\x17"\x90J\xd2\xf7I\xa9\xc8\x98\xf3\xbb\xa0@I&\xd0\
\x98\x08k\xbc\x1f#CJ\x00\x18\x86\x81\x85\xf5\x9a\xcc9\x86\x81\x17\xf8\x00\
\xc1\x04\x13\xc7\xd7\xa3$\xdb\xf3\x04\x1e\xb7\xdb\xf9\xc73_.Vw\x84\xfc\x92\
\xba\xce\x00\x00\x00\x00IEND\xaeB`\x82' 

def getITBitmap():
    return BitmapFromImage(getITImage())

def getITImage():
    stream = cStringIO.StringIO(getITData())
    return ImageFromStream(stream)

index.append('IT')
catalog['IT'] = ImageClass()
catalog['IT'].getData = getITData
catalog['IT'].getImage = getITImage
catalog['IT'].getBitmap = getITBitmap


#----------------------------------------------------------------------
def getJMData():
    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\xc8IDAT(\x91U\x91OH\x13p\x1c\xc5\xdf\xfeD\xb5\x9af\x1b\x83r5\x8b2\
\xbd\x8c\x9c\x11\x91yH")\xf3P\xd0!D(\xa1S\x05\x1d\x83\xe8\x12H7oE\xd4!\x98\
\x82\x07\xb1C\x97\xe8\x1f\x1d\xcaH\xcc"\xda lm\x14h9\xb2\x8d9k\xfb\xbe\xef\
\xf7\xb7\x0e3\xa8\xc7;\xbc\xcb\xe7\xf0\xde\xf3\xd4\xdea\xa1\x8cS\x1f1\x9d\
\x07\x008\xc0\x01\xfa\x8f\x05\xa8\x00\x11\xbc\x8f#\x1a\x80\xe7t\x17\x92cW\
\xd7m\xc0t\xc1=.\xba\x92\x9a\xc2\xcc\xa9\xd6T\x9d*\xb9\xde\xab\xfd\x8d<\x1c\
\xd2_E\xee\xeex\xe0\x9f\x98B\xf7\xfd\xda\x91\xc4\xfc\xfe=\xb6\xddk\xf7\xbe\
\xf3\xcd\xb2\xb1F:\x92\x8c\x07x!,\xd1\xa0\xcc\xbe\xe6\xd8\xd3mK\x80\x0f\xc0\
\xde\xceC\x8f^\x14\xe5\xb7\xedkaw\xc8|N>\xac\xa8s\x1c\x08\xc9\xe5\xa8\x04\
\xc9\xbb\xe3r\xfd\x0e\xab\x16\xccf\xb3~\x00fV\xa9\xea\xc4\x13\x9dM\xeb`\x1fO\
\xee`\xfb\x1a\x9a\xb1- \xa9\xb4\x8c\x8cr&%$7\x93\x00\xbc\x00T\x8d$\xc9t\x86\
\xd7n2\xf7UZ\x83\xd2\xd6 \xb9/r\xe9\x06gRR\x97\xaa\xae\x02f\xaa\xaaBi\x8e\
\xc8\x95\xb3\x12\xdb"\x99\xa2\xcc\x15\xaa\xb1\xad2|\xb1\xba\xaby\x15 \t\xc0\
\x0f\x80\xa4\xaa\x9c\xe8\xd2\xc1\xe3\xb26\xc8\xc9y\xb9\xf5\x8d\xe2x>,g\x12\
\x1c\xdd)#I\xde\x9eTSE\xbd\xf4\xd1\x9e\x8e\xa1\xbe\xa5\xfe^\xfe$\x87s\x92\
\xccK\xd9X6y^`\xaa\xc4\xceF9v\x90\xf1\x98~Zh\x9a\xfb\xbc\xe8io\xc4\xd4\xcb\
\xa1\x8d\x9b\xf8\xea\x07\xc7\xf3\xb6(\xaco\xaaN\xe9\xa8\xd4&\x9f\x9e\x0b[o\
\xc4\ny\x8b\xf5\xa4<+\xcf\xb0PB\xe2-\x963\xff\xbf+\x7fs\x05P\xa0\x05\x0f\x0f\
\xa0\xb5\x01\x7f\x00\xbc\xc6>\x16W\xa20\xbb\x00\x00\x00\x00IEND\xaeB`\x82' 

def getJMBitmap():
    return BitmapFromImage(getJMImage())

def getJMImage():
    stream = cStringIO.StringIO(getJMData())
    return ImageFromStream(stream)

index.append('JM')
catalog['JM'] = ImageClass()
catalog['JM'].getData = getJMData
catalog['JM'].getImage = getJMImage
catalog['JM'].getBitmap = getJMBitmap


#----------------------------------------------------------------------
def getJOData():
    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-IDAT(\x91\x95\x8e1K\x9bq\x18\xc4\xef\x8do\x9d\x84\x82\xb8d\x08\xc4j\
\xbf\x80[\xd6N\xa1\x05!\x93 \x08n\x85.\x8e\x1d\\]\xba\xd4\xecnYJ\xa1 \x84R\
\x08\x8a\x90!k\xb7|\x80@\xbb\x15$S\xe0\x7f\xcf=\xe7\xa0\x91\x0e\xef\xe2\x8f\
\xe3\xb8\xe1\x0e\x0eWx\x19\x95\x81\x7f\xe7\xe7\x13`\x9e\x99\x99\x92"$\xc5\
\x13$\xd7Nr<\x1e\xd7\x00v\xe0\xe3?\x7f\xef\xa4o\xd2\x92\x94\xc4g\n\x0bK)\x85\
d\xa7\xd3\x01P\x03p\x1a\xd2;i\x97\xec\xf6?\xf8\xf4\xc4MTU\xb5X,Z\t@\xc2\xc1\
\x813\xbb\x0cO~y4j\x1c\xd8\xce\xcc\x16\x00\xec\xef\xfb\xec\xcc\xbd\x9eI/\x97\
\x1e\x8d\xfc\xf5\xb2\xa1\x0eDD\r\xc0\xf3\xb9\x87CO\xa7`\xb1k\x1f\x0e\xfc\xe9\
c\xc3%\x1b@+\x01\x93\xbe\xbd\xc5j\xb5\xd8*~\xdfol\x03x\xbcT\'\xb0\x11a\xf2\
\xe6-\x87\xfdM\xea\xba\xfc\xfcN\x91bQaF$)Fj\xef\xf5\x9b\xd9\xc5\xacN\xe0~3~\
\x1c\xb5\x7f\xef\xbdj+"\x83"\x93\x91\x11\n9\x98!I\x96R\x08T_\x80\xcf\x03`\
\x1b(k\xc5\x7f!\xd6!\x81\x00\x80\x07\xb8\x86[\xb9\xc4\xb5\xea\x16\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getJOBitmap():
    return BitmapFromImage(getJOImage())

def getJOImage():
    stream = cStringIO.StringIO(getJOData())
    return ImageFromStream(stream)

index.append('JO')
catalog['JO'] = ImageClass()
catalog['JO'].getData = getJOData
catalog['JO'].getImage = getJOImage
catalog['JO'].getBitmap = getJOBitmap


#----------------------------------------------------------------------
def getJPData():
    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\x03IDAT(\x91u\x91=n\x021\x10\x85\xc7\xab\xad\xb6\xd8\x06\xd1Pp\x0cJ\
\x0e@CAK\x81\x94\\\x0c%\x1d\xe2\x02\x144\xe4\x1a[ \x12i\x9bEB\x82"ck\xbe\x14\
\xfe\t)\xf2d\xd93\xd6\x1b\xbd\xf7l\xf7x<\xe4\tf\x16\xf7\xe7\xa2 \x98\xd5"\
\xd24\x8d\x88\x00q\x06b\x97\x8f\'\xf4}_g\x12\xbf\xc5\xf1\xc8\xe9\x03\xaf\xcc\
f,\x16\x85\xed\x9c\xb3\xa8\xf0\x87\xbd\xdf\xb3\xdd\x12\x02\xea9\x9d\xf8\xfa\
\xe4\xe55\x0eD\x87Uq\x0f\xc80\xb0\xdb\xe1=\xaai\xbd\xbds\xb9\x14\x91\x10B\
\x15\xc3\x15\x8f\xdcn\x89\xea\x15U\xeew\xceg\xb2\x84\x99\xd5f\x96{d<\xa6\xaa\
\xf0\x8azT\xf1\x1e\x11&\x93\x94\x01\x92\xa5\xc2g4b\xb9\xe4[\x13[\x95\xd5\x8a\
\xe9\xb4\xbc\x98\x88\xd4\xc5R\x9a\xdclh\x1a\x0e\x07T\x99\xcfY\xafKb\x11\t!\
\xb8a\x18\xda\xb6-\xb7\xa9\x88>\x9d\xcbiE\x04\x11\xe9\xba\xae6\xb3\xeb\xf5\
\x9a?2X\xb0\xff\x10E~\x00&\x93l\x9f\x04-\x9d\xc4\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getJPBitmap():
    return BitmapFromImage(getJPImage())

def getJPImage():
    stream = cStringIO.StringIO(getJPData())
    return ImageFromStream(stream)

index.append('JP')
catalog['JP'] = ImageClass()
catalog['JP'].getData = getJPData
catalog['JP'].getImage = getJPImage
catalog['JP'].getBitmap = getJPBitmap


#----------------------------------------------------------------------
def getKEData():
    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\x01zIDAT(\x91\x95\x8e?OSa\x1c\x85\xcf{{\xd1Bjt\xb1\xeaRH7C\x98\xf4S\xf8\
\x11\xca``E\xc3l\x1ae"awgbq\xad\x8b\x0b\xd1\x81\xa5\xeeDo\x1bcro\x03\xd2\x08\
\xd2\xa0\x97{\xdf\xf3\xfb\xe3B\x13W\x9f\x9c\xe1I\x9e\xe5\x00\xffI\x00\xd0\
\xef\xf7\x01\xd8\x1cU%)"\xa2\xea\xaaU]\x0bI\x11\x92\x83\xc1 \x01\x00\xf8d2)\
\x8a"\xcf\xf3\xfc\xf4\xb4\xb7\xbe\xde\x9e\xcd\x1e\\\xfc\xda\xd8\xdc\xfcV\x14\
\xe3\xf18\x1b\x8d\xb2,#\t \x1c\x0f\x87\xdd\xb557\xf39\xe5tj\x07\x07\x10\xb1^\
o\xa9\xdd\xbe\tfI\xda8\x1a\xbc\x0fg\xc0\x9d\xd7;:9q\x11\x17Bd\xa7\xfa\xb3\
\x1d\xd2\x05\xd57\xb3\x8b\xdd\xda\xac\xaa=FWM\x97;\xa3\xc3\x0fi\t4\xcbJ\xaf~\
\xbb\x88G&&\xe7\xbc\xd6\x85\xa6S\xa7\xe5\xb5F\xf7:Z\xa4KDUG \xbd\x05$I@\x08\
\x16\xe0!\x04\x0f\x97Bx#Qm\xa9\x05\x8a1\x82\x02\xb5\xa0\x06 \x1c\x7f\xf9\xd8\
]y\xaa\xaa7W\xdd.\x7f\xe4x\xbb\x9f\x88\xd6[\xcf\xef=\xea\xb8\x9b\xbb\x9by\
\xdaH?\x1d\xbd\x0bx\x85\x17\xcf^~\xbd\xca\xa8\xa4\xc5h~\xdb\x16\x9f\x8c\x19"\
\x0f\xbb<\xd7\x9f\xd1JQ\x8a\xe9\xea\xdd\xc7\x9f\xf7\x86)*\x88p\xa5\xd9\xa1RL\
h\xa4\xf1\xfb\xaa\xd0\xf8P\xe5\xbe\xb5\xdcA\x13u15T\x08\xd8\x06*@\x808\x9f\
\xfc#2\x17\x03\x04h\xe1/[b=+\x9c\x1eE7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getKEBitmap():
    return BitmapFromImage(getKEImage())

def getKEImage():
    stream = cStringIO.StringIO(getKEData())
    return ImageFromStream(stream)

index.append('KE')
catalog['KE'] = ImageClass()
catalog['KE'].getData = getKEData
catalog['KE'].getImage = getKEImage
catalog['KE'].getBitmap = getKEBitmap


#----------------------------------------------------------------------
def getKGData():
    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*IDAT(\x91mQ1j\x95a\x10\x9c\xef\xcb\x13+\t\x06,\x02\xbeF\x1b\x83\x85\
\xe29r\xa3\xdc\xc4\xca3\xe4\x02\x96b\x11\xc1\xc2Z\x84H\x82] \x81\xbc\x99\xd9\
\x1d\x8b\xff\x7f\x89\x85\xcb\xb2l\xb1\xbb3\xb33n\xf0\x18\xbd\xaf\xff6\x0fi\
\x00\xc0\x06\xc0\xd3\xb33\x00\xe9F7\xaa\xe2B9v\xecH\xb1!\xb5\x1d\xe9\xcf\xf9\
\xf9\x06\x00\x90\xbe\xfc\x8d\xaaTE\xc2\x93\x1a[a\xa8\xbf\xabo\x15\xb1\xc9Hs\
\xbb5\xb0i \x9d\xc7\xe9Q\x9bS\xce\x0fFi\x9cp\xf7\x89}\xa7\x90\x91"50\x01\xa0\
\xea\x01}\xbe\xe1x-\x7f\xa5\xbfp\xbc\xe2\xc1\tC\x86+H\x03\xb3\x01\xb8\x96\
\x03\xa1\xc6\x0b\xe5\x80\xb9f]\xb1\x07\xf3rO\x89\x8c\xed\x05!\x8bD1b\xfd"\
\xee\x98C\xe2h\x97[\xf6\xe5n\x9d&[\xc2\xaaAZ\x0e\x80\xf47\x8d\xb7\x9c\xef\
\x95R\xfd\xa0>+;Fj{\xda\xbd.,\x02VV\xbc\xff\xc8\xf9N\xb9\xa7/\xd47\n\xd9\x16\
\\\xa9\xda\x7fI\x1e\xc7\xc7C\x8a\xab\xad!\xe5\xa7b\xcf\xe7\x1a\xcf\xdc\xf6\\\
~X\x05`\\\x01\xde\x1b\xd9\xffswq}\xb1y\x02\x7f\x01\xf6\xe7T\x82\x00#5\xea\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getKGBitmap():
    return BitmapFromImage(getKGImage())

def getKGImage():
    stream = cStringIO.StringIO(getKGData())
    return ImageFromStream(stream)

index.append('KG')
catalog['KG'] = ImageClass()
catalog['KG'].getData = getKGData
catalog['KG'].getImage = getKGImage
catalog['KG'].getBitmap = getKGBitmap


#----------------------------------------------------------------------
def getKHData():
    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\x01mIDAT(\x91]\x91\xb1jTa\x10\x85\xcf\xfd\xbdw\xf7\x86u\xafkX\xc8\xaa\
\xb8hc)\x16\x06+;\x03na\x13|\x07\xed\x15AE\xb1\xb05\xe0#\x08\xa9\x0c\xbe\x81\
\xc4B\xdf"6\x12\xb5\x10\xab &;\xe7\xcc\x8c\xc5M 8|\x0c\xa7\x18f8s*\x8c?\xc1\
\x02}\t\xf0\x00zt\xd2O\x0b\xd40\xbc\xda\xba\x06 \x03\x1e\xe9\x01\xf7\xf0H)\
\xe8p\x85\xd4\xeb$c\xe7\xed\x97\x1a\xf8\xd3\xa6\xfd\xfc\xb5\xf4\xc8\xf0\x90g\
?a\x1ebHI\x06\x19&\xbf\xb4\xd6\x02\xbf\xeb\xcf\xcb{W\x7f<\xb5\xfd\xfdpO2=\
\xdc\x96\x83\xd9,<\x0e\xbf\xeeA\xee\xcb\xa34Kr0\x9f\xdf\xc6\xc7\x02\x00\xee)\
U$\\\xa3\x1b\xd7\x07\x93s\xb3\xe7\xcf.\xbc|\xd1\x8cGgo\xad\xc3\x95fi\x06\x12\
@\x11\x10\xf2 EfUV\x1f<\x1c\xdd]\xa0]A\xdbv\x9b\xf7\xa7\x8f\x1eg\xdd\xc8Lf\
\x92\x8e\x80\x1a\x00\\\x90\x92vf\xa5+]\xd7m\xdc)\x93\xf3i\xd6-\x16e2)\x83\
\xe6x}\x7f!\x80$\xc3\x0c\xee\x17\xdfl\x01\xa8\x9a&3\xb3\xae\xab\xe10\x81\xf9\
\xf6v\x95\x1eRH\x02*\xe0\xdd\x93\xd77\xbf}\xffK\x86PH\'\x83tcPA\x85<yH\xb9_\
\xb9<\xda\xddy_\x03\xdd\x01\x87\xe3iC\xf5^\x82\xc7\x8f\x0f)\xddS\xbd\x88<\
\xf0\x04\xa6\x15\xf0\x01\xb0\x93 \xff\xe3t\xd2=\xe5\x1f\x8c43\xadX\xc5\xfd\
\x9e\x00\x00\x00\x00IEND\xaeB`\x82' 

def getKHBitmap():
    return BitmapFromImage(getKHImage())

def getKHImage():
    stream = cStringIO.StringIO(getKHData())
    return ImageFromStream(stream)

index.append('KH')
catalog['KH'] = ImageClass()
catalog['KH'].getData = getKHData
catalog['KH'].getImage = getKHImage
catalog['KH'].getBitmap = getKHBitmap


#----------------------------------------------------------------------
def getKRData():
    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\xcaIDAT(\x91MQKO\x13a\x14\xbd_[\x98v\xc6\xb6\xd3N\x19\xd2\x8e$ \xc5\
\tFTR\x16\xae5\xd2\x86\x1f`p\xe7\x0f\xf0\xc1\xd6\x10m\xe2\x9e\x05\x0b\xfb\'\
\x84\xb8\x9a\x85\x89\xc1\xd7\xaa\x89\x8f\xa8q\xd1E\t\x01R\xfa\x98\x89S\xb5)u\
>\xefa1b8\xc9\xc9=\xabs\xcf\xc9\x11\xfd\xe1\x80\xce\x80\x99\x89\x889T\xffx\n\
\xc9\xcc\x11"J\xc5\xd5T\\m\xed\xed\x7f\xff\xfce\x0c"\x15\xd7tUMkZFK&\xa2\xd1\
o\x1f>\x1e4\x9b\x13\xe9\xb4\xa9g\x999\x16\x1a\xf7z=\xc7q\xfc\x1f~\xce4ggf\
\xd0lBJ\x14\x8b\xadvg{{K\xcfd\x8cl\xf6\xfc\xd4\x94\x0c?\x00\xf0}?\x08\x82\
\xc5\xa5\xd2l!\x8f\x8d\r\xac\xad\xe1\xc1=<Y\x9f6\'\x96WV\\\xd7=j\xb7\x010\
\xb3\xe8\x0f\x07I%AD\xddnWM&\xc5\xab7\xf1g\x9b\x08\x82\xdf22\x1a\xfd\xd1\xef\
\xae\xfe\\\xbd\xd3\xef\xb9\x05\xab \x84\xd8k\x1d\xc6\xc2\x96\x00r\xb9\x1c\
\x11\xbdtS%\x19\r"\x89\xa7\x8b\x0f[#e\xfd\xe0\xd3UE\xd1\xac\x02\x00\x12B2\
\xc7\x98\t\x00\x00\xcf\xf3\xcei\xea\xc0^\xb8o?\x8a\x8e\x8f\xed+\xa6\x7f<j\
\x96\x96\xed\xe1/\xd7\xeb\xe7\xf3y\x01\x10s\x84\x98\x014\x1a\x8dZ\xad\xe68N\
\xe5Zb\xeez\xf10\x9a\xa5\xe1\xf1\xcd\xcb\xe3\xb7nX;;\xaf\xab\xd5j\xbd^\x0f;\
\xc4\x98\x88\x88TU\x05\xf0\xf6\xdd\xfb\xf9K\xf3\x8fo_\xfc\xba\xa4\xc8\xbfX\
\x98Vvw\x1b\xcf\xb7^\x18\x86\xa1\xeb:\x800\x12\x03\xb0,\xab\\.w:\x1d\xd3\xcc\
\x13\xd1\x95\x0bj\x98sr\xb2P\xa9T\x0c\xc3\xb0m\x9b\x88\x88I\x1cy\xde\xd9!\
\xff\x1f\x92,O\x87&)%\x111\x11\xf1\t\x851\x197fc:\xfd\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getKRBitmap():
    return BitmapFromImage(getKRImage())

def getKRImage():
    stream = cStringIO.StringIO(getKRData())
    return ImageFromStream(stream)

index.append('KR')
catalog['KR'] = ImageClass()
catalog['KR'].getData = getKRData
catalog['KR'].getImage = getKRImage
catalog['KR'].getBitmap = getKRBitmap


#----------------------------------------------------------------------
def getKWData():
    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(IDAT(\x91}Q?J\x1dq\x18\x9c\xdd\xac"\xf1a\xf1L\xc4\'H\x1aO\x10\xde\
\x01\xbc\x84\x9e!\x9dm\xe0\x9d\xc0>\xea\rr\x80W\xe4\x06\x1e\xc0\xda\xd6\xb4!\
\x10\x91\xe57\x7f\xbe\x14\xeb\x96\xfa1\xc50\x0c|3L\x07\x00\xd7\xc0\x1e0\x02#\
\xa0\x19\x99I\x9b!@\x18\x00l\xb2\xc1W\xe4c\xc2\xb8\xac\xd8\x91J\x8a\x14\xd2R\
\xc8\x88\xe6\xf6f;\x00\xc0s=\xfd\xfc\xeds\xfb\xd04\x1d3dH\x93fski4O\x17\xa7\
\x181\x00H\xca\xff\xac_\xbe\xbc\xba8\xf8|\xe08\x89\xcb\xa9$veR\xf6w\xf6w\xbf\
\xed\x0e\x00lK\xd2\xa8\xf5r}\xb2:\xa97\xae\xeb\xba\xf5b=\x00\x90LRR\x90\xb7\
\xdcU\x85\xaeK\xd2\x03\x98\x1e46\xbfc\xafBU\x92\x01\x00\xc9\xd6ZA\xba\xbf\
\xcfriO\xf9]\xf6\xd4\x02I%\xfdb\xf1|w7E\xd2\x00~\x7f\xe1\x97\xdb\xdb\x97\xd6\
\xaa\xb5"\xab\xb5\x90\xafD\x84\xfc\xe1\xec\xec\xef\xc3\xc3\x00 \x9d~|Z\x1d\
\x93\xa3\xdc\x8b5\xf9\xa4\x9e\x9c\xc6\xe8m\xd8e\xf7@\x07\xe0\x118\x02\xfe\
\x00\x99\xf7\xc5L&\x05\xb3\x08\xe0?\x9dhe)?\xb4zO\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getKWBitmap():
    return BitmapFromImage(getKWImage())

def getKWImage():
    stream = cStringIO.StringIO(getKWData())
    return ImageFromStream(stream)

index.append('KW')
catalog['KW'] = ImageClass()
catalog['KW'].getData = getKWData
catalog['KW'].getImage = getKWImage
catalog['KW'].getBitmap = getKWBitmap


#----------------------------------------------------------------------
def getKZData():
    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\x93IDAT(\x91M\xd1\xdfk\xcdq\x1c\xc7\xf1\xd7\xf7{\xbeZ\xedp6\xbb`\
\x895\x8d\xd4\xb2R\xc8\xcd\x8ar\xa1\x95\xbbq\xc1%\x85\x1b\xb9\x14W\xee\xdc-\
\xb5\xab\x15%\x94\x1b'w\xd2\xa2\xa3\xfc*WrA\x9aq3+t\x9cM\x93s\xbe\xdf\xf7\
\xe7\xf9r\x83\xfc\x01\x8f\xabGVk\xf9\x83\xb2\xf1\xc2\xfdR\x88\xd5\x90BB\n\
\x04\x02\x05\xcaQ\xa0@\xa5\xb2Z\xcb\x9d\x9d3\xcb\x1ay\xa4\xe9da%\t(\xdc\xedQ\
\xeb\xaaH8\xe1\xb0+\xfb\xda\x8b\xb5B\xd2\xb2\xb6\xdd\xaa\xa6s\x0b\x14v\xd8[y\
\xbf\xc7\xad6\x1b\x1f\xfb\xe8\x1a}\t\x07\xde\xdc\x97\xa9$\x97$\xf9\x98\xe7\
\x12\xea\xd9\xc9\x98j\x9f\xe7'\xb9\x7f\x90\xe6\x01\x1e\xfc\xc2\x15\xae\xec\
\xc0\x82<\x89a\x7f\xbc\xcb\xd9\xb03W9\xdd\xba\xdb\xe3~f\xf5\x1aZ\xda\xeb\x87\
uV*\\%\x87\xadR\xb9\x90\x9d\x8e{\xb6\xb4\x07\xf8\xd2O{\x17\xaf^\xa7\xfd\x8e\
\xb2\x13\x83oc\xf7Dz^\xe1\nG\x92\x82B\xa1\xcf\x1e\xb9\xed\x93\xe0\x1f\xd4\
\x87\xbd8\xe1'\xf78\xb5\xc0\xf6o\x0c\xad\xd08\xec;\xf3\x1c\t\x1cXA\xae\xc0N'\
\x98\x01\xb5\xbda\x95\xfa\xa746\xe5\x1b\x93n\x8e\xfa\xcdy_h3\x148P\xb2E\x14\
\x12[X\xb8\xc8\x15\xe1d-\xb2\xe3\x1dc\xeb\xf9:\xe5\x9b\x83,\xcd\xa5\xcbO}(\
\xfb\x03$T(\xc0\xd5\xb9u\xd7\x9b>\x1d(\xac\n\x05\x9b^\xfa\x0c\xd0\xf1\xc0(N\
\xce\x12N\x96\x82L\xcd\x9fW\xa3q)\xff\xfe\xefR\xe5\xdf\xd7\xf8oZ\xa8+\xe5\
\xfa\r\xbfiZs\xa4\xc5\x10\x93\x00\x00\x00\x00IEND\xaeB`\x82" 

def getKZBitmap():
    return BitmapFromImage(getKZImage())

def getKZImage():
    stream = cStringIO.StringIO(getKZData())
    return ImageFromStream(stream)

index.append('KZ')
catalog['KZ'] = ImageClass()
catalog['KZ'].getData = getKZData
catalog['KZ'].getImage = getKZImage
catalog['KZ'].getBitmap = getKZBitmap


#----------------------------------------------------------------------
def getLAData():
    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\x01fIDAT(\x91e\x91\xbdj\x94a\x10\x85\xcf\xfb\xedg\x84EML\\\x15\xd4\x14n\
\x99\xde\xd6NH\xa1\x16\xa9\xacDHc\xb7\x9d\x84\x08\xb9\x06\t\xd8\xda\n6\xb2w\
\xe0}\x98""\xf9\xc1h4\x89d\xbfw\xce9c\xb1\x18V\x9cbx\x0e\x87\x81\x81\xa7\x08\
\xff\x8c\x01\xff\x85\x8b8\xcbE@\xd9\xdc\x04\x906\xec\x94@A\x04\x99dF\\lD\x9c\
\x8d\xc7\xed\xa8\xf7tm\xf0\xe0\xe4\xf08e\xcb\x96j\'\x86D\xa5\x08Y\xa4H\x06\
\xe7o/na\xdcn\xdf\x1f\xdd[\x1c\xee\xab\xa3SBW\xb54\xdf>{4\xc8\xccw\xe3\xfd\
\x9d\xbdI\x01*\x15\xf4\x9d\x1b\x97w\xf0\xa6\x01\x1dBu\t\x95\t]\x9a\xf2\xea\
\xf9\xdd\x95a\x7fe\xd8\xdfx\xb1<7\xd7\x9c\xd5\xecX:\x96\xce\x05\xa8\r\xaa\
\x950%*:-\\i\xae\xf6{\x99\x99\x99\xd7\xaf\xf5n-\xf4\xeay0\xc8 %\x80\rh\xc9\
\xd5\xa8\xca0\x0e\xbe\xc7\xc9oN\x0f\x8e~\xc5\xeeAG\xa0cV&#\x01\xb6\xa8\xa42\
\xc2T\xda8>\xe7\xc6\xdb\xdd\xf5\'7\x01l\x7f\xd8;\xfc\xc9\xa6\xa0\xd2\xa2\x95\
\x06\\\x1e\xe3\xe1\xfa\xd6\xcb\x1f_\xbf)$\x8a\xc1:\x99\xfe \x85\x9b\x94(\x89\
\xa2\x97\x96\x07\xa3\x8f\xaf\xdb\xf7\xf8t\xe9\xcb\x10\x8c\x8cH*\x19p\xd8\x91\
\xc9\xccH\x12$$K\xf8\xacU\xa0\x9c\xfe\'\x953<\xad8\xe3\xfe\x0fF\xcfDl\xce\
\x11\xc4\\\x00\x00\x00\x00IEND\xaeB`\x82' 

def getLABitmap():
    return BitmapFromImage(getLAImage())

def getLAImage():
    stream = cStringIO.StringIO(getLAData())
    return ImageFromStream(stream)

index.append('LA')
catalog['LA'] = ImageClass()
catalog['LA'].getData = getLAData
catalog['LA'].getImage = getLAImage
catalog['LA'].getBitmap = getLABitmap


#----------------------------------------------------------------------
def getLBData():
    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\x01PIDAT(\x91UQ\xbdJ\x1e\x01\x10\x9c=\x0f\xedD;\xb9\x88\x82\xcf\xa0\xe6\
-\xf2\x0c\t1V>A|\x00mEk!u:-\xa2!\xa4\xb2\x08\x12\x90\xf8EL\xa1D\x94\xc4\x0f\
\x0b\x1b\xf13\xdf\xed\xecN\x8a\xe3N]\x96a\x16f\x96\xfd\xb1\xdfx\x8cl\xb1!ly\
\xb6\x9c@\t`j}\x15\x802\x91\xa9\x08E\x88T\x10\xa4\xe8"\x93.\x12\xf4\x9f\x1fv\
J\x00(\xcb\xb8\xfe\x8b\xa4\x18\n\xaa\xd5\x89\xae\xda\xd3]\xacU{QM\'P\x8e^]\
\x8dU\x15\x00H\x92\x00\xbb\xb9\xbf\xd9>\xdc\xfe7|x\xf3\xf2m5^)S\x92$3\x8c.\
\x1d\x15(\n\x98\xc1Lf\xb0B\x86\xfd\xf3/\xc7\xfd\xde\xf7\xfe\xd1\xde\xd9\xbe+\
\x05\xb4i\xcc,2\xb3\xed.A\xc7\xfd\xde\xe7\xd3\xbd\xdb\x87\xdb\xda\x87\xbb\
\xbd\x9d_\xfd\x13u\x01dc\xe8\xd4)m\x1dl\x86B\t\x0f\xaf\xc3\xd7\xbe\xae\xb3\
\xd3K$\xcb\xce\xd0\xac\xb1\xf1j\xe3\xcf\xdd\xf5\xf2\xc7\xa5P\xbc\x9b\x7f\xbd\
0\xb3\x18\xe9\x86\x91f\n\x00v\n\xbcx\xbf\x12\x97\x17b\x9d\xeer\xcfz(:\xeb\
\xa1\x91"\xe5\x14]\xc1rv\xee\xdb\xa7\xc3\x92\x80\x06\x03\x9b\x98\x04\xbd`\
\x88n\xee\xa2\x17\xce\xa4\xa3\xb9r\x84\x18\xba\x1f\x00\xb0\x1f\xcf\x1f\x99O\
\x1e\xdc\x95h\x11\xc0\x7f\x10SD\xe6\xa3\x9b\x8a\x95\x00\x00\x00\x00IEND\xaeB\
`\x82' 

def getLBBitmap():
    return BitmapFromImage(getLBImage())

def getLBImage():
    stream = cStringIO.StringIO(getLBData())
    return ImageFromStream(stream)

index.append('LB')
catalog['LB'] = ImageClass()
catalog['LB'].getData = getLBData
catalog['LB'].getImage = getLBImage
catalog['LB'].getBitmap = getLBBitmap


#----------------------------------------------------------------------
def getLIData():
    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\x01VIDAT(\x91e\x8c1j\x94a\x18\x84\xe7\xff\xf6\xd3\x10%\x8bFX\x08\xb2B"\
\x06,\x02B\xca\xdc\xc0#\x08\xde\xc2\x0b\x08z\x894)\xc5J\xd2\x05\xb5\xf0\x00\
\x82\x85\x18\x90X\xc4FQ\x82``\x97\xe4\x9d\x99\xf7\xb5\xd8\xa4P\xe1a\x98\x81\
\x87\x190}\x81\x04\x1a\x80\x06\x01\x12bA\xc2\t\x08\x10\x10\x97E\x1d\xc2\xd3\
\xe7\xdbwV\x7f\xde\xbd\xf5\xed\xc1\xf4\xcb\xfb\xaf\xeb\x87\xdf\xd7\x8fOV\xa5\
R\x96\x94rJI\xa5\x9c/\x9f\xedw4\x00\xf5ps\x7f\xa9\x9f5\xc5\xce\xf4hc\xbc\xf2\
\xe4\xe3c2\xe9\xa4L%\x95\xa4oO\x96\x015\x00Y8\xf8\xb4u\xfd\xea|it&\xeb\xd5\
\x87mr\xa1:\x94A\x07\x1dJ)\x81\xe8\xc8\xc6\x1c\xde~\xdezs\xb8)\xe7\xb9\xafP\
\x08\x9b\x86\x88\x10\xe8!\x04\n\xe7\x06\xd0\xfa\xfd\xd3\x83{\xf3\xf1\x8d\xd9\
o\xa9,[\xb4$\xa5h\xd2\x92MI\x96<\xb9v\xf35v\xfb\xbb\xd9\xde\xca\xaf1~\x1c\
\x97\xa3\xa8"\x8b\xf1\x7f\xa68j\x1b\x8f0\xebs`\xd9\xd4\xc2V$Y\x8a\x14KLE\x91\
\xa5(\xb1\xa4\x91u\x02t\x00%\x15\x99\xe4\xc5\x19\xa3\xc8\xbc\xf8f1JL\xbb\xd9\
\t\xf4\x04J\x1a&kM\x84\x9c\xe4`&\xd9\xa4\x14!\x95\x94\xe9f\xc3N`8\x02\x04\
\xe4e\xe2\xef\xf9\x0f\x00\xfe\x00}\xfba\x01\x98\xd1\xdd\xe0\x00\x00\x00\x00I\
END\xaeB`\x82' 

def getLIBitmap():
    return BitmapFromImage(getLIImage())

def getLIImage():
    stream = cStringIO.StringIO(getLIData())
    return ImageFromStream(stream)

index.append('LI')
catalog['LI'] = ImageClass()
catalog['LI'].getData = getLIData
catalog['LI'].getImage = getLIImage
catalog['LI'].getBitmap = getLIBitmap


#----------------------------------------------------------------------
def getLTData():
    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 IDAT(\x91U\x8d1N\x9cQ\x0c\x84\xe7_\x1eB4\xa1\x06\nN\x80\xe8\xb8A$N\
\xc4\x05\xa2\xdc#m\x8a4\xa9\xd3p\x02D\xa2TTP \x05\xa5B+\x81<\xe3\x99\x14oY\
\x82e\x8d>\xdbc{\xe1o@\xd8\x86\x05\x030\xe0\r[\xaf,x\x85\x01au\xf4\t@\xd2\
\x88w\xd0;1\xa2l\xd3B\x98\x08\xe6\xd3\xaf\xafc\xac\x80\x05\xd1\xc3\x92\x9e>\
\xa4\xe7\x18\x99Y1c.\xbb\xc7\x00\xc6\xcf5\x8eJ,&=O\xdaL4MNy\x82kw\xaf\xae\
\x1f1\xce~\xe0\xf2\xe3\xf3\xfdz\xad\x96,\x9a4\xd9,\x93]\xd5\xc5\xe6\xd4\x93\
\x0f\x07W_0\xf0\x02\xb9\xd9\x94%\x8b\xcdr\xb1I\xb3\xba\xaa\xdf\xd6\xd4\xc2\
\x1a\x03@G\x8a\xca\xa5\x9e\x1f\xaa\xbcY+\x17\'\x87\x0c\x01\x8co\x9fq\x1a>\
\xdf\x95\xa9\xa8\xbahM\x1b\xcd\xdah3\xd4\xfe\x89\xbe\xdf`\x9c\x03\x07\x7f\
\xd5\x7f\x18\xd2d\xaaR\xb5\x81mG\x8cz\xec\xf7\x050\nh*\x87\x87!\xa1\x8e\x18\
\x12$$\x90\x8b\x04)\xddK\xb7\xba_\x80\xe5\x16\x10\xe0W\xf5\xfb\x12\xff\xf5\r\
\xac\x80\x7f%"wC\xeb\n\x9e\x0b\x00\x00\x00\x00IEND\xaeB`\x82' 

def getLTBitmap():
    return BitmapFromImage(getLTImage())

def getLTImage():
    stream = cStringIO.StringIO(getLTData())
    return ImageFromStream(stream)

index.append('LT')
catalog['LT'] = ImageClass()
catalog['LT'].getData = getLTData
catalog['LT'].getImage = getLTImage
catalog['LT'].getBitmap = getLTBitmap


#----------------------------------------------------------------------
def getLUData():
    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\x1aIDAT(\x91}\x8f1J\x83Q\x10\x84\xe7%\xafPD\xe3\x0fb\x04AA\x11l\xac\
\xbd\x85\x95x\x12\x0bm\x03\x16\x9e\xc2s\xe8\t,<\x86\x95\xbf\x81\xa8\x11\xc3{\
;3\x16\x7fL\x1auX\x86o\x87ea\x92OO\xf0>\x01\x00@\x12J f(\xa1RT\xaa\nT!,'c\
\xf2\x8a\xeb\x11\x00K\xc9B\xd0\x16\xc8D\xf5\xc9^T\x93&\x1d\xd5\xe4tt\x9b1+\
\xa8\xc5\xed\x0bDP\x8e\x00\xc3\xa4\x83\x8e\xea\x1a\x8e\xea\xa8\xae5\rw\x04d\
\x9c\x9d\xfb\xe0\x08[\xdb\xa0l\x822\xe9\xb9\x87I\x8b\x8e0\x89\xc1@\xfb\xc34\
\x1e\x8f\x9b\xa6\x01`\x1b\x86\xe1\xbf\x94Rj\xdb6wu\xbbh\x01\xbf\n)I\xca\xcb\
\xa3\xff\xff\xdb\xc9\x96\x94/\x1f7.\x8e=\xf92\x05\xda\x94)\x87\xbc\xe0\xae\
\x8e\x84f\xd5W\xf7\xfd|\xf7\xa4\xc3\xcd\xfe\xf3\x87+\x11r\xa5+\x1dt\x95c\x01\
r\x08{\xebx{@\x06\xd4Cow\ra\x07A\x81BU\xea \xd4%\x89\xb6\x04d\xa5t\xf3\xe9\
\xa9\x10B\x11\x8a\x10@\xf9Y\xa59\xabs`\x05\xdf\xe1\xc4yk:}\nf\x00\x00\x00\
\x00IEND\xaeB`\x82" 

def getLUBitmap():
    return BitmapFromImage(getLUImage())

def getLUImage():
    stream = cStringIO.StringIO(getLUData())
    return ImageFromStream(stream)

index.append('LU')
catalog['LU'] = ImageClass()
catalog['LU'].getData = getLUData
catalog['LU'].getImage = getLUImage
catalog['LU'].getBitmap = getLUBitmap


#----------------------------------------------------------------------
def getLVData():
    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\x1aIDAT(\x91u\x911jBQ\x10E\xef\x93\x87B\x14R\x0bj\xe1^\xd2d)\xf6!\
\x85\x0bH\x9d2\xdbp\x13b\xf3\xb7`\x08I\x11H\xa1\x92\x80\xcc\x9d;\x93\xe2\xff\
/\xa6\xc80\\\xee\x83\x997\xc3\x9c\xf2\x0c\x9c\xd1E\x00\xde\xebuZ\xaf\x03\xa0\
~\x03w\xeb5\x80\x8c\xc8\x88\x94\xc2\x15\xf2t\x0f\xf7 \xe5\x1ed\xb8\x8b|\xd9l\
j\x05\x80\xfcy\xffH)\xa4 [\x15\x19\xa4\x8c\xa2\x85\x99\xc8\xf1|\x1e@=\x03\
\x1e\xc9\xebj3\xb9\x87Q4\xd1d\x94\x99\xc8!y\x02\xca\xe7n7Y,d\x96\x99\x88H \
\xda\xdd2;\x13\xdd\xa3\x0e\x87\xaf\xdbm\x91TJ\xc9\xcc\xcc\x04\x90\xffG\x19\
\x0c\x8e\x87C\xfdj\x9a\xf1l&3t\x7ff^&\xf4\xbe\x1dUG\xa3\xb7\xdd\xae<\x02\xf7\
\xab\xd5q\xbf\x0fw\x99\x05\xbb\x8du1f\xed\x95n\x97\xcb\xa7\xa6\xa9\x01\x84{\
\x92\xd1\xa6Y\x98\x05\x99fIfk\x9c\xe9J\t@5 \xe97\xd3i\x90\xe1\x92\xf7\x9d=\
\x84t\x97\xd4\x1e\xdd\x81\xf2\x00\x9cz\x90v\x05\xd5\xfebn\xf1O\x80_|(\x81I\
\x94\xd8|\xd3\x00\x00\x00\x00IEND\xaeB`\x82' 

def getLVBitmap():
    return BitmapFromImage(getLVImage())

def getLVImage():
    stream = cStringIO.StringIO(getLVData())
    return ImageFromStream(stream)

index.append('LV')
catalog['LV'] = ImageClass()
catalog['LV'].getData = getLVData
catalog['LV'].getImage = getLVImage
catalog['LV'].getBitmap = getLVBitmap


#----------------------------------------------------------------------
def getLYData():
    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\x00\xdcIDAT(\x91UQ\xdbm\xc3@\x0cc\x00\x7f\xa4\x13\xb4@F\xe9tA\xa6\xe8\
\x00\xfd\xc8b\x99\xa1\x10\x1f\xea\x87l\xc7>\x08\x82tG\x8a<\xe8\x82\x1f\x9c\
\x8e\x80\x00\xdab\xeaz\xe7\x05\xc0\xe3\xfb\xd1@\xe0t\xdcN\xa2H-\xb5\x14)b(\
\x8b\xcd\xe7\xefs\x01\xd0\xe8\xd7\xdf\xcb\xb1\xdb\x83\x18\xd0D\x85t1\xbc}\
\xdcV\x85t\x1c\xcf<\xc7\x0c\x15\x95\x8bM\x864iVJ-\x14\x16\x04\x86\xc7\xc3\
\xa0WP\xc8Tmu\xb9hBC\x88\xd5b\xe4h\x83\xb2R4+dj.\x1d\xa3\xb0@pkl\xec\xe8\xf1\
p$\xcbb\xb8\x12d\xd3\xdc?:\xea\xbb\x08\x9b\xf3*\x0b\x19B\xebd\xfd0\xbeB\x852\
\x19\xbb\ra\x81\xc0\xf0\xf3\xfa\xe5\x88\x91\xf2\x96\x92eH\xb6"\xb7\xddFp\xc1\
\xfd\xb4\xc85O\x91C;+\x07\xfe\x01\x7f(\x90\xf3\x07b\x051\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getLYBitmap():
    return BitmapFromImage(getLYImage())

def getLYImage():
    stream = cStringIO.StringIO(getLYData())
    return ImageFromStream(stream)

index.append('LY')
catalog['LY'] = ImageClass()
catalog['LY'].getData = getLYData
catalog['LY'].getImage = getLYImage
catalog['LY'].getBitmap = getLYBitmap


#----------------------------------------------------------------------
def getMAData():
    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\x00\xecIDAT(\x91}Q1J\x04A\x10\xac9\x17\xb9/\x9c\xb0\xa9`bb\xe0\xe3\xeeW\
\xf7\x8cCCA\x033\xcd\r\xee\x10\xbb\xaa\xbb\x0cf\x8f\xdd\x05\xb1)\x8aa\xa6\
\x8b\xae\xa9n\xc6\\\xb5>\xff\x89f\x00\xfb=\x00W\xa1\n\x99V"e\t\x92I/\xf8t8\
\x0c\x00\x00\xfb\xe3\x13\x99\xc84\xd9yB\xd0\x0cG\x98l\xe3X\xc0\x00\xc0\xe5Uw\
DI&\x11a\x86\x83]\x00\xb2\x80\xa1\x80\x96\t\xc9\x12(\x8b\xdf\xe6\xf3=K|8\xc6\
\xf5O\x98\xb3\x00\xc0\x06\x00\xb4\xf0@\xbe\xdf\xc4y\x1b\xa7m\xbc\x8e\x97\xee\
\x0e\xe9b)e\xc9\x0cP&o\xdf\xe2\xcbL\xc5\xdd\x0b\xbd\x98\xd0fK\xa4# \xf5\x87\
\r\xe3\xf1\x89&\x8b\x0b?\x92%u\xc1U\xff\xe2\x14\xcb\x94\x89#\xe6\x1b\x11Jd\
\xa2\x0b6\x14v;\x93PB\x04\xd9HH\xe8,\xf5\x0c\x91Y@;\xaf\x17\xf9\xcf\x8e{\xfd\
\x02\xf9\xcbZ\xc0\x13\xfe\x86t\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMABitmap():
    return BitmapFromImage(getMAImage())

def getMAImage():
    stream = cStringIO.StringIO(getMAData())
    return ImageFromStream(stream)

index.append('MA')
catalog['MA'] = ImageClass()
catalog['MA'].getData = getMAData
catalog['MA'].getImage = getMAImage
catalog['MA'].getBitmap = getMABitmap


#----------------------------------------------------------------------
def getMCData():
    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\x00\xc9IDAT(\x91\x85\x8fKj\x03A\x10C_\x0f\xed\x0bxi\x98\x93\xfaV\xbe\
\x81O\xe1\x0b$`\xf06\xabn\xb5\x94E\x0fN\x868\x89(\n\x15%\xd5\xa7\x84/x\xcf_F\
\tp>\x03\xb1\xb1\x19#\x1a\x0cEBJ\xef\xf9\x96?.\x97\n@\xf2\xf6\xce\x18\x8c\
\x91\xdeg\xde\xa2\xf5\xf4\x96\xd6\xd2{YWC\x05\xe2\xec\xd4\xadE\xda\xa4\xbd\
\xa5\xf5i\xa0wC5\x941\x90"\xd1\x15\xbd\x98\xfd4\x00\x95\xc3\x81uM\xad\x19\
\x9e\xa7o\x17\xffx\x80\xd3\xc9\xd7ky<\x1e\xc7\xe31I\x08!\xbfcY\x96\xdb\xedVm\
\xcf\x1a\xfeR\xcf\xae\xedj{\x16\xff\x1a\x00I\xdb\x86\xa7g\xa2\x94\xc2\x0e\
\x05\xb6n\xb5}\xbf\xdf%I\xb2=\x17>\xb9$c\x8c\xa4eY\x80OS\x16bnhr\xec\xe5\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getMCBitmap():
    return BitmapFromImage(getMCImage())

def getMCImage():
    stream = cStringIO.StringIO(getMCData())
    return ImageFromStream(stream)

index.append('MC')
catalog['MC'] = ImageClass()
catalog['MC'].getData = getMCData
catalog['MC'].getImage = getMCImage
catalog['MC'].getBitmap = getMCBitmap


#----------------------------------------------------------------------
def getMDData():
    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[IDAT(\x91=\x90\xbbjUa\x14\x84g\xef\xb3O4\xde@\x82\x10"^\xba\xe0\x1b\
\xf8\x02\xc1\xc2ti\xa2\x82\x96\xb6\x01K[\x1b+\x1f@{\xb1\xb1\xb2\x8bh\xb0\xb1\
\xb5\x13\xac\x04\x8d`$\xa2D\x0f\xc9?\xb3f,\xce6\xc3\xc7T\xb3f`uX\xdc\xc6\xb1\
\x84\xfa\xb4\x86\x01\xf8\x05\x1b>\x05\x1b\x1fVa@\x18}\x00\xf0\xe8\xc9*\x802l\
tK\x0f\x93\xe0,\xbb\xd4$\x07}\xa6W\xb6\x141%S\x1f\x9f=\x1f\x00 \xd8\xfd\xc1\
\xaaT%\xfa\x82\xe9\xc1\xab\x97\xa7]\xbc\xb9>Kx\xf4\x99!C\x0e+\x17\x1b\xd0\
\xc3(c\x9eV\x05\xa9\xbd\xdd\xbazi\xd6\x0e\xf9\xf5\xdb\xdf\xa4\x85\xcd#2\xd0C\
p\xa0\x8a\xca\x94\x13\xee\xbc^<\xff\xb4]\x7f3\xdb\xd9^\x88\x9b\x1b\xddZ\xb5\
\x16Q\xc0\x80\xb2\x14\xcd]NX\xd5\x9d\xb9\xd1b\xea{\x1f7S&C\xfe?\x80\xca&\xad\
\x8a\xe8\xb8I\xdd\xc6\xdb\xc7\xa4\xef\\\xdbJ8\xa6IK\x06\x06\xc0\x92\xa9P.:i\
\x9b\xb7\xd8\x8e\x1e\x94\xda\xdd{\x7fb\xa6)\xa2\xc9\xa8\xc6\x05\x16(\xcf+bf\
\xf8y{\x83vK\xc7\xf8\xa49\x7fk\xb9\xc6\x05I^^\x9aJa\x19\x93\x15\xf8\xc2\xe4\
\x1c{+\xf9\x8d\xc9\x89\x85\xcb\x95*W\xa1\xca@\x07\xbc\x00t\xcc\xfe\xfb\xfb\
\xee\xe1C\xd8#\xef\xd6`\x8c\x00\xf8\x07p\xbadU\xf1\xb3\x17s\x00\x00\x00\x00I\
END\xaeB`\x82' 

def getMDBitmap():
    return BitmapFromImage(getMDImage())

def getMDImage():
    stream = cStringIO.StringIO(getMDData())
    return ImageFromStream(stream)

index.append('MD')
catalog['MD'] = ImageClass()
catalog['MD'].getData = getMDData
catalog['MD'].getImage = getMDImage
catalog['MD'].getBitmap = getMDBitmap


#----------------------------------------------------------------------
def getMGData():
    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\x00IDAT(\x91u\x8e=NB\x01\x10\x84\xe7\xc9K\x88\tF\x12\n*\x1a\x1b.\
\xe49<\x85\\\x88CXx\rD\x121\xa1\x90\x86\x9d\xd9Y\x8b\xf7\x83\xc6\xb8\xd9L\
\xb6\xf8ff\x9b\xd3\xe9\x84al\xcf\x17\x8b\xfe\xfeg[\x00\xf3\xf9\x1c@U\x01\xc0\
fS\xc7O\xa4\x1ai"\xdd\x90%\xd5\xa0\xe7\xed\xb6\xed\xf2z\x1a\xa8\xfd\x1e\x87C\
\x91\xfd\x06\x8bQ\x11E6\xabU\xdfp\xa5\xab UDI=\xca\xa8`g\x00i\xa0\xb5}\xa5\
\x0b\x15\xfa\x9b=\x1a0\x1a\xaa\xaa\xeb9Ny\x9e\x85\xc5"\xcd0iF1R\x9c\xde\xebe\
|\xa9\xfa|<=\xf2\xfd+\xa2\x18\x93`2\x1cLF\x06\xcd\x87;\xbe^\xd0\xda\x1e\xe3\
\xab*\x15\x17\x06\xcd_tRVN\x84\x8f\x1f/u:\xe6\rJf\xc8\x94SNhh\x18=\xcb\xdb\
\xa5\xd3,\xca\xa2\xa9\x94J\x99\x99\x95\xe9D\xa0\xd9\xedv\xb6mK\xb2\xbd~^\xe3\
\r0p\x03\x08\x10\x10\x80\x00\x03\x02f\xf8\x06$\xb0c\x1f\xc6\x92\xeb\xa7\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getMGBitmap():
    return BitmapFromImage(getMGImage())

def getMGImage():
    stream = cStringIO.StringIO(getMGData())
    return ImageFromStream(stream)

index.append('MG')
catalog['MG'] = ImageClass()
catalog['MG'].getData = getMGData
catalog['MG'].getImage = getMGImage
catalog['MG'].getBitmap = getMGBitmap


#----------------------------------------------------------------------
def getMKData():
    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(\x91=\xc9=H\x96a\x18\x86\xe1\xf3\xf5{\xdb\xc2\xa6\xa0"%\nB\
\xfa\x01\r\x9cl\xa8\xad\xa1\x9f)\x88\x96\x9a\xac1j1\x82\xa0Q\xa7\x88\x86&\t\
\x02\xa9)\xca\xad\xa2\xa5\xc1\x8a\xc8\xa1%,\xfb\xe1\xc3\xa1\xc0D\xf2\xd3\xba\
\xaf\xfby\xae\x16\t\xce\xe98\xb1\xf1%\x0c\x86\xf2\xbf.\xea\xf2\x176\xa0\x07\
\xbfa\x15VFX^\xa1e\x02n\xdf\xe0*~\\\x9b\x95J)\xceBd\xd3dg<\xfbB\xce\xf4V\xf9\
BzHk\xa7\x9f\xb6L\xc2\x0e{t\x89\xf3\x85\x99\xe2w\xa2\x14/\xca\xad\xfcY\x0ey8\
|9\xbc\xa0fz\xa0\xbe\xa2\x05\xfc\xd3\xdc+\xec+>&\xb6\x15?\x0b\xcf\xa7\x91\t\
\x9f\x08\x1f\x90\'\xc3o\xc4\xa0*\xb4u\x94f\xb0\xf0\'\xbd\x98,\xa4\x0f\xcaG\
\xe4Q\xb9\xca\xcb\xe1_\xe1)y=\xbcK\x0c\x89\x17\xb4\xbc\x06\x8a\xd7\xe5\xb5\
\xe4{\xfa\xbdLxL\xb6\xfc!\xdc\x93o\x86\xf7\x86\xfbE\x7f\xd6\xeb\xb4\x1c\xc5\
\x17\xd3\x1f\xd3?\x82\x8d\xf4\x90\xdc\t\xcf\xc9\x0e\x7f\x93\xd7\xc3\x8fd\x87\
\xb7\xab9\xacz\x87\xb6\xce\xd1\x8c\xc8_\x83\x81\xf4\xd9\xf0\x17\xf9IX\xb2\
\xe5\x97\xe1\x93\xf2\x95\xf0\x031\x9f^\xcd\x84\xb6B\xa7?=.\x0e\xc9\xd3\xf2\
\xf3p\x84\x87\xe5-\xe1\x87\xf2}\xf9xxJ\xbc-\xcc\x16\xa0\xad\xa7\xe8\x9bH\xba\
;}W,\x15v\x0b\xa9\xd9/\xfa\x92=B\xc9\xa7\xe4V\xe1Z\xe1L\xa9\x034\xbd\x1e\xf5\
\x1cu\x96\n\x15\x80\nu\x8eZ\xa9c\x9b\xb8\xb9:\xb0\xc0?\xef\x8fD\x87?\xdeS\
\xdf\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMKBitmap():
    return BitmapFromImage(getMKImage())

def getMKImage():
    stream = cStringIO.StringIO(getMKData())
    return ImageFromStream(stream)

index.append('MK')
catalog['MK'] = ImageClass()
catalog['MK'].getData = getMKData
catalog['MK'].getImage = getMKImage
catalog['MK'].getBitmap = getMKBitmap


#----------------------------------------------------------------------
def getMMData():
    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\x17IDAT(\x91m\x91\xb1.DQ\x10\x86\xbfs]\x8bH\xb4(\xb6PP\xf1 \x1eE\
\xaf\xdd\x87\xd9\x9e\xc6\x13\xe8\xc4;\x08\xc9\xb6"\xe2b\xaf;\xff\x9c3\x8a\
\xc3\x8dE2\x99f\xfe\xef\x9f\x7f2\tn\xc0\x01\x98\x80A\x81\x16:qZ\xe0o\xb5\xe0\
\xb3\xd9\xc1\xee\xde\xe4\xe4x\xf3\xe3#\xae\xaf\xbb\xbeO)+\xf9\xd9\x9a{#\x85{\
|\xf7\xb7\xab\xab\x16X_o\x8e\x0e7\xa6\xd3I)\xf4\xfd\xf6|\xfe\x8c,t\x1fR\x98B\
\x16f!\xa5\xe9\xb4n\xa0\x94\x80\x88H\x11\xa5D\x98\x95\xe4\xe5K*\x0bS\x05\x90\
*\xd0\xf4\x037\xb7\xbd\x89\xf7e\xbe\xb8|\x91\x1aT\xc2l\xf4\x1e\x01\xea}1\x0c\
w\x0f\xc3\xe3\xe2\xb5\xeb|\xf9\x9c\x93Q\xa4\x15u\x05\xdc\x0b\xb4O\x9cn\xe5\
\xf3\xdc/J\'$\xa4\x90\x1a\xeb\xc3\x86\xd1\xfb\xeb\x86\x1ai\x07\x92\x96a\xaf\
\xb8\xff\x1c\xffR\xe3\x1e\xee\x0em\x815\xf7\xf8\xf6\x1e\x03\xac`.<\x933\x15h\
\xe4\xec\xef\x87\x84g\\HI\xc2\x9d\xda\xdd\xc9\xb9V\x81\xf4\xbe\xfaH\xfe\xfb\
\xee8\x02>\x013\xecV\x12\x92s\xba\xce\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMMBitmap():
    return BitmapFromImage(getMMImage())

def getMMImage():
    stream = cStringIO.StringIO(getMMData())
    return ImageFromStream(stream)

index.append('MM')
catalog['MM'] = ImageClass()
catalog['MM'].getData = getMMData
catalog['MM'].getImage = getMMImage
catalog['MM'].getBitmap = getMMBitmap


#----------------------------------------------------------------------
def getMNData():
    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\x1eIDAT(\x91]\x91\xb1j\x95A\x14\x84\xbf\xfd\xef\x1f\x14\xb1\x88$\
\x85Q\xd2\x88\x92w\xc8;X\x85@\n\xdf$\xf8 \xbeF^\xc0\xde\xd6\xc2\xc2JDA\x10A\
\xbc\t\xc9\xce\xecN\x8a\xfdo\xee\xc5\xc3\x14{\x0e3g\xe6\xb0%l\xab\xc3\x8a_p\
\xb8\xe9:\xdc\\\xf3\xaco\x9a\x0e3\xc0\xe5%\xa7\xe4S/\xb7\xfd}\x7f\xfaO\xa5\
\xb5\xd8\xc5^\xa1\xc7{~\x17)v\xa4\xf5\xd5\xd5\x0c@r\xf4\x83\xdf\x8d?\xed\xbb\
\xdb_GZ\x90\xda\xbb\xbe\xa6\xd6H\xe5\xf8\xb8\xc3\x04\xe4m\xd8o\\\xb4H2\xb5F\
\x8a\xea\xa0\xf5\xd4\xba@\xea0w(\x1f\x1bo\x9c/f\xb2o\x97\xddC\x96\x9a\x07)\
\x12\xc3\x81\xf3\x16\x943\xe5P\xda\xae{\xd0lF\xf6rt\x8a\xf3\xda\x99+\xb2\xd4\
\x07u\xb0\xd9q(\xdbH]q\x05\xa7\xd6Zsw\xb7M\xc5p\x90\xb0c{\x08V\xcd\xf9)\x1e)\
\xd6\x7fy\x16\x81\x85\x1b\xad1\x04\xd3\x07\xb3>\xca,h/^NO\x84Tl$\x8a\xa7\xe2\
W\xb46\xd0\xa1\\\xef\xfcb\x87\x03>\xc3\xf3\x9d\xc1\xfa\x1b'\xe35\xea\x1e\x9e\
\x19N\x12\xd7\xb1\x80\xd6\x00\x00\x00\x00IEND\xaeB`\x82" 

def getMNBitmap():
    return BitmapFromImage(getMNImage())

def getMNImage():
    stream = cStringIO.StringIO(getMNData())
    return ImageFromStream(stream)

index.append('MN')
catalog['MN'] = ImageClass()
catalog['MN'].getData = getMNData
catalog['MN'].getImage = getMNImage
catalog['MN'].getBitmap = getMNBitmap


#----------------------------------------------------------------------
def getMOData():
    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\x8fIDAT(\x91M\x911kSq\x14\xc5\xcf{\xfe\t\x94\x17i\xea\x12\x1a\x89b&\
[l\xd5\xa5K\xa9\x93\xfd\x08\xdd\x04A\x14AA\x04\xa3\x82\xdd\xfc\x06\xea\xe4\
\xecj\x87v\xe8\xe4"H\xc1I\x17W\xa1j\xea\x10H\xa0\xe4\x91\xf7\xee=\xf7^\x87\
\x18\xe8\x19~\x9c\xe5\xc0\x81_\x867@\x85\xffq\x80s\xca\xbc\xcc\xfa\x8c\t\t\
\x13\xecn\xef\x02\xf0p\x0f\xb70\xd2\xb2\x9c\x00\'5\x19\xaaN\xba\xaaSM\x0f\
\xde\x1f$$\x00\xf1\xa7\x1cX\x98\x99yh\x91\xccB\xef\xb6\xb3w\xc7\xe5\x84zZ\
\x8b\x84\xa8i\xb7\xd9\x85#\x87\xc3=\xcc\x8dn\x1ez\xaf\x93\x97*E\xba\xf4\xb9\
\xbc)ND\xfd\xb4\x0b\xa1\x08EM!\xc8\x01\x18\x8cA\x9aF\xf0\xc3\xdfr\\\xf3\xf6\
\xc5\xed\xfe\xfa\x0b\xb1\x82.o\x7fO\x84"&\xea\xb3\x01A75U\xd7;m\xac\xb6\xb6\
\x1e\\\xbd\xbf\xdaZA\xc4\xb3\xf5\'\x0fW^\x8d+\xbc\xbc\x9c\x8b\t\x8d \xce\xe1\
\x166z\x1b\xa3z$._\xc7\xf2\xf8\xda\xa3\xcd\xf6f#o\x9c\x94\'\xd7/\xdc8\xdfh.5\
Z\xaf\x7f|\xd2\xd0\xc5\xc6\xe2\xe0\xcb \x81\xd0P1\xa1SM\xfaG\xfd\x85\xb4P\
\xb3\x9er\x9a\xb24\xaaF\xc3\xe9P]\xe94\'\x88\x04\x82\xc6\xd9%5\x9dj\xb5se\
\xa7St\xd6\x96\xd6\x0e\x7f\x1d~\x1b~\xdf\xfb\xf9\x91\xa1t\xa3\x1b\x88\x84\n\
\xea\\.\x96\xd5\x94n\xa4\xee\x1f\xef\xbb;\x9d\x95Ut\xf6Z=3\xb30s\x83 \xc3s\
\xe0t.R\xe6R\xab3\xa6\xe5\x8c\xfe&\xfe\x01\xbfA>\xd1U\xf8Jr\x00\x00\x00\x00I\
END\xaeB`\x82' 

def getMOBitmap():
    return BitmapFromImage(getMOImage())

def getMOImage():
    stream = cStringIO.StringIO(getMOData())
    return ImageFromStream(stream)

index.append('MO')
catalog['MO'] = ImageClass()
catalog['MO'].getData = getMOData
catalog['MO'].getImage = getMOImage
catalog['MO'].getBitmap = getMOBitmap


#----------------------------------------------------------------------
def getMTData():
    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\x00\xefIDAT(\x91m\x91\xb1n\xc2P\x0cEo^\xdc\xad\xf4\x0b`b\xa1e@\x0ce\xe1\
\xaf\xf84\xfe&R\xd521\x04\x06\xa2\xd0\xe5\xd9\xcf\xb7\xc3KB\xd2\xf6\xca\xb2<\
\xdcsm\xc9E\xd34pG\x08\x18\xc9\xaf\xd7\xe7\xe5\xd2\x81\xbf%"\xf2$RU\xd5z\xfd\
\x86"\x00 \x01\x11\x1e\x0ee\xdb\x06U\x9a\xb1\xef\xf7\xe3Q\xdc\xec\xe3\xeb\
\xb3>\x9fMu\xb3\xdd\x92\x04\xc0\x94x:\xf1vcTjd\x8cT-\x16\x0b\x07$\x88\xacV\
\xaf\xed\xfd\xfb\xe1&\xe9\xce\x98}\x91Q3\x00U\x07\xc4\xdd\x11\xc2\xfbnG\x12\
\x04\xc1N\xaa=\xf3\x00\xd0\x01\xe8\\\xc3@r\xe2\xce\x80Y\xb7\xa1sL\xf2{`\xb4\
\xa1\xc8\'\xfd\x1f\xef\x1c|C<\xcdl|\xd2\x04\xa0O\xe2Ma\t)a\xd80\xf4\xac\xa2,\
1\x9fc6\x83\x19\xcc\x90R.\x07\x8a\xcb\xe5bf\xde\xab\x9b\xeb\xfae\xbf\xff\xf5\
\xe3\xac\x1f5\xa6Z\xed\x19\x00\xa0J\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMTBitmap():
    return BitmapFromImage(getMTImage())

def getMTImage():
    stream = cStringIO.StringIO(getMTData())
    return ImageFromStream(stream)

index.append('MT')
catalog['MT'] = ImageClass()
catalog['MT'].getData = getMTData
catalog['MT'].getImage = getMTImage
catalog['MT'].getBitmap = getMTBitmap


#----------------------------------------------------------------------
def getMXData():
    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\x01pIDAT(\x91E\x90A\x8b\xcdq\x18\x85\xcf\xff7\xff\xb9MHw\xee4\x84fjV\
\x94\x05\x1b\x1b\xba\x1b\xb3\xe1#H\xf2\x05,|\x05\x0b\x0b\x1bek\xe1\x0b\xd8+\
\x16b\xa1\xa4\xc4\x94\r\xe9R2e\xa2\xa4\x1b\xd7\xfb\x9e\xf7\x1c\x8b\xff\x94g\
\xf1\xecNO\x9d\x0e\xd7\x0f\xa2\xf5\x18 \xbf\xdd\x9d54I\x00$q\xb1\xd8\xdb\xda\
\x02@@\x80\x80\x1eh\xb7\xae\xde\x01:\xa9\xa2r\xb2\xba\xd6\xba\x06\xd86\x00g.\
\xdf\xb8\tYEg~xp\xbf\x07\x00c\xf7\xd7^\xa9\xfed\xd8F\xe7\xff\xc81\xfbl\xcb\
\x99K\xc7\x8f\r\x05\xc9*\x89*\x8a\x86m\xcf\xde=\x93\xb4q\xea\xc2\x92\xad\x0c\
H"\x1b\x93@\x83X\x16]\xac\xca\xa2\xed/\xef_~\xff\xf4\xf6\xe1\xbd\xdb\x1f\xdf\
<6\xe0\x08e*RI\x01="Jb1\x8b\xac\xb2=\x1a\x1f\x99\xb7\xc3\x076O\x8fO\x9c\xb4d\
R%\x91&\t4\xd0Te1\x8b\xa1\xb4\xfd\xf4\xf5\x8b\xaf+\x93\xd5\xb3g\x9e\xbcz.[\
\x11\xca4\xd3L\x00\r\x04\xc5\xa1\x10\x19\x86/\x9e\xdb\xd6\xfc\x07\xab\xb6\
\xcf_\xb2]\x91\xceT\xa4Y\x04z\x04\x8aC!\xa3hy2^\xbfr\xf9\xda\xfeI\x11\xce\
\xb0a\x95K\xfb\x83\x14\x8f\x1eZ\xcb\xca\xdf\xf9\xb7\xeb:\x00\x83\x01t\xad-on\
\x00\xb0,\xa6\x80\x0eS\x80\xc0\x02\x10\xf0\x13;\x8fvFmDR\x92\xa4\x98\xcfw\
\xa7\xd3\x06\x10\x00\xd0\x80\x7f\xfa\xa3T\xf0\xfd[\xcfL\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getMXBitmap():
    return BitmapFromImage(getMXImage())

def getMXImage():
    stream = cStringIO.StringIO(getMXData())
    return ImageFromStream(stream)

index.append('MX')
catalog['MX'] = ImageClass()
catalog['MX'].getData = getMXData
catalog['MX'].getImage = getMXImage
catalog['MX'].getBitmap = getMXBitmap


#----------------------------------------------------------------------
def getMYData():
    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\xa2IDAT(\x91M\x91?h\x14a\x10\xc5\xdf\x97o\xbd\xec\x99Ssb\x1a=\x0c\
\x111\x8d\x04,\xec\x04\xb5\xf4*\xab\x80V\xa2\xbd\x1b,\x0cXZ\xa5\xb0\x11%""X\
\xa4\x886\x86\x88\xd8DR]\xe0*\xff\x80\xc8\xa1\xb9;C\xbc\x8b\x9a\xc6?$\xee7\
\xb3\xf3,v\xa3N\xf1\xf8\xcd\x14\x8f73\x0ehV\xcb\xaf\x17\xe7n\x01\xa8_\xbc\
\xf63\x9d\x00\x0c\xb0&N\x0f\xe7\x04\xe8\x7f\xea\xaa\xe5\xfb\x9f:\x1e\xc0rc\
\xfc\xf8\xf8Z\xa9\x94>}~\xe2C{\xff\xcc\xcd\x03\x83>#@3\xee\xd4\xaf^/\xba~u\
\x118\xbf\xd2\xdcwrb\xa5\xb2{\x0b\x96\xd5\xcf\xf6\xa7^Nn^\xbe\x12#\xa5(%\x98\
\x08C\xf0\xb5C\x1f\xe7\x1fG\x00\x00\xdb\xf8R9vd\xa0\x12\xeb\xd6\xb6\'3\x11\
\x0c?\x98\x8d\xbd\x92F\x16\xe2\xbc?\x9aL\xb9!\x7f\xefk\xdf\x98\xf5g\xee\xd4/\
M.\x83:\xfb\xe8\xd4\xab\xb7\x07\x1f\x96\xa6\xcbHM\xd5D\x18\x84*\xbeV{\xbf\
\xb0\xe0\x80\xc6\xdd\xdbC\xe7\xce\xbc \xb3\xe4\xc6\x05Q\x86`"|\xf6d\xa4\xec\
\x03\xc9b\x07\xc0y\xff\xbd\xddvM\xe0p2\x9dv\xd7 b*Ta\x10\x0b\x12\xcb\x0f\x17\
\x0fR\xc4Dr\xdd5:\xfani\xc9I\xff\xb3\xdb\xb3\x97Y\x06\xa2\x08\x9b\x876+\xbc\
\xcdH\x82tQ\xb4\xb9\xba\xeaZ\xc0H\x92h\xb7k"T\xa5\x88\xe5\x99D\x18\x02E,\x1f\
fYil\xecM\xa3\xe1\xb6;\x9d\xa8Z-lv\xae\x0e\xb3\x7f\x1f\x00h\x06\x12\xc0\xb7V\
+\n\x1b\xbd\xdf\xeb\xebff\xaa\xa6\xfa\x17T\xd5\xcc\x90\xf7\x9a\x83\r\x00\x7f\
\x00\xba\x16Z\xd9\x8b\xc35\x87\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMYBitmap():
    return BitmapFromImage(getMYImage())

def getMYImage():
    stream = cStringIO.StringIO(getMYData())
    return ImageFromStream(stream)

index.append('MY')
catalog['MY'] = ImageClass()
catalog['MY'].getData = getMYData
catalog['MY'].getImage = getMYImage
catalog['MY'].getBitmap = getMYBitmap


#----------------------------------------------------------------------
def getMZData():
    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\x85IDAT(\x91M\xc6=k\x93a\x18\xc5\xf1s7wbmm\xe9\xd2B\x84G-t\x14:\xfb\
\x05\x04\xc1I\xd0M\xbbw\x13\x17Q\xac\x8e\x82\x8asqpr\x10q\t\x88/\x9f@:\xd5.\
\xd5I\x17\x8bi\x92\xa21\x89\xe9}\xae\xeb\\\x0e\xf2\x80\xf0\xe7wNz\xb2\x8e[\
\xd7\x80S\xc0\x14\x10`\xb5\xffWj3R\x00\xdf\x9e\xde\xed\xac\xe3\xc7\x92T\xe4\
\xe1&w\x99\x85\x99\xccD\xba\x99H\x19\x9d\x9d\xedN\x06p\xae\x1f\x1b/\xbf?\xbf\
\xe0;\xabN\xd2\xe5tR\xa4HgQ)^\xe8\xac\xe6+dd\x00\xa1XL\xbe\xf9\xde\xaf\xde\
\xbf\xd9l\x9f\x8d\x88\x88P\xa8\x1eE\x84\xa4\x9c\xf3\xfe\xe9\xfd<\x01>\xcf\
\xf9\xeae\xfb\xf3\xc2\xda[\x8f\xf6\x98\x9f\x91\x074\x92,\xa5\x904\xb2\x90du\
\xa6\xea|\xe8\xcc\x14\xa0}1m\xbd^Y\xd8\x98\x8b49?\x1e\\\x19\xf5{\xa3^o\xd4;\
\xfc\xd7\xf0\xb0;\xecv\x87\xdd\xc1x\x00 O\x81Wo\xfc\xe1\xf5\xc9\xd1\xbb\xd9\
\xd9#\xff\xe8\xcdmC!\nACa\xa2\xa1X\xa25h-\x00\xe9\x18h\xdc\xd9\x8c\xdd\xaf\
\x987=\xb8\xf7ki\xc1$D\x84\x14\x92B\x90\x14\x1eR\xa3y\xf2\xcb\xde\xdb\x0c\
\x00}\x8b\x06q\x89h\xdd^\xfc]B%\xc4Z\x86J\x04\x11\x9eN\xac\xad\x1d|\xca\x02f\
\x96\r7\xdaQ\x11SG\x10\xc1\x14\x04\x0c \x92!\x19\xe0\x08\xc7\xb1\xab\x8f4^\
\x86\x1eC+\xd0O\xc8\x00\x83\x04\x19T \xd5\xdf \x00\x06\xb4\xf0\x17\x9ffI\x92\
\x19^\x18d\x00\x00\x00\x00IEND\xaeB`\x82' 

def getMZBitmap():
    return BitmapFromImage(getMZImage())

def getMZImage():
    stream = cStringIO.StringIO(getMZData())
    return ImageFromStream(stream)

index.append('MZ')
catalog['MZ'] = ImageClass()
catalog['MZ'].getData = getMZData
catalog['MZ'].getImage = getMZImage
catalog['MZ'].getBitmap = getMZBitmap


#----------------------------------------------------------------------
def getNGData():
    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\x1eIDAT(\x91u\x91\xb1NUa\x10\x84\xbfs9\xe1\x9a@"\xb9\r\xa1\xa0\xa1\
\xe1A\x88\xbd\x0f@m|\x01+\x1a+{K_\x83\x97\xe0!(h\xb4\xa1 \x91`r\xf2\xef\xcc\
\xac\xc5\x89J N\xb1\xcd\xce\xe6\x9b\xc9N|\x85\x05\x80\x80\xb8\xfbpw\xb4\x7f\
\x94\x04H\xf2\xb0<\x9c\x7f9G\x10\x1803\xf3\xc4\xd5\xbb\xabu\x9d\xce\xf1\xeex\
\xbby\x03\xdd\xdd\xc0\xb6\xb6\x97\xef/EUT\xae\xebo\xd733\xd0\xdf\x7f\xfdpl;\
\t\x9b\xfe+\xc7\xb7?oGF\xa5N\x0fO\t3!i\xc7\x8a\xe5\xeaW\x1a\x1e#\xa3\\\xe5b0\
\x03\xc6j)R\xf4\xc2\x9ddx\x0c\x8fJU\xd6\x03\xa1\xb8\\\xb2\x145\xaf\x08\x1ak$\
Y\x88\x19\xe1H\xd1\xc8\x90_\x12\xfeE\xeag\x84\xea\x1a\x1e\xb2\xca\xa3\xd3\
\xfd\xact:\xc3\xa3\xba\x149\x7f\x08\xb2\xd6N\xf5\x9f\xd2\xeaR[1bf\xa1\xa2\
\x93\x83\x93rI\x9e\xa6\tX\'\xb0\xb7\xd9;{{\xe6\xb6\xdb\x8e\x19L|\x82G\x10,\
\xb0p\xf3\xf9f\xb7\xbf[?-\xe9\xfe\xe9\xfe\xe2\xe3\x05\x01@p\xc8o\xd3|v \xc0\
\xdc6\xb7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getNGBitmap():
    return BitmapFromImage(getNGImage())

def getNGImage():
    stream = cStringIO.StringIO(getNGData())
    return ImageFromStream(stream)

index.append('NG')
catalog['NG'] = ImageClass()
catalog['NG'].getData = getNGData
catalog['NG'].getImage = getNGImage
catalog['NG'].getBitmap = getNGBitmap


#----------------------------------------------------------------------
def getNIData():
    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;IDAT(\x91]Q\xb1jT\x01\x10\x9c\xbd{\x81\xdc)\x1c\xc1\x84\x08*i\x8c\
\xadM\x04K\xfd\x824\xf9\x88\xb4\xf7\x05\x81\x14\xfe\x82\x95\x85\xa5 \x88U\
\xc0_H\x93\xb46WY)A\x1fw\x9e\xbc\xdd\x99I\xf1\xee\xe0\xcea`a\x99e\x99\x99\
\xc0\xd4\xe8\xb0\x82\x84\xc2\x9aB\t\xdd6\x81\x06\x1d.\xce\x00@\xb6\x1c\x14h\
\x94LFi\x98\x1c\x94\\t\xca%\x7f\xbe\x9c7(\xc0\xf8\xd1\x9a\x02\x85\x92\x8bH9\
\xb9\xd2e\xb9\xa3\x93~:\t\xfcU\xf3\xea\x04\xc7\xfb\xde\x1bA\x06\xd5\x9f\x99Z\
R\x95\x1a\x17\xdd\x7f(\xf9`\x8c\xafo\x14$#\x02\x80m\x18\x86=\xff\x90\xf3V\
\xcaf<\xf2\x83s\xaf\x11\x11m\xdb\x0ez\xb7\xab]?\xd9]\xcd^|\xff\xf2\xc7Lo\x02\
\x90\xd4l\xaa\xb1\xba\x88\xb7G7|\xb6kl\xe9\xc3\x96\x14/\xdf\xe7\xf4u\xfc\\x\
\xed\xd8%E\xfe\xa6\xb5\xd4\x84B\xd1e\x938|\x18\xef>\xfejn\xbf\xe9\xfa\xc9pv\
\xe7$:\xf6\x99 5\xc9r\x96\xbb>S\xba\x88\xe7\x8f\x80OhPJ\x0c\x1eOPt\x12%$\x91\
\x8c"R\x10\x91F1d\x97\x00(p\xba\xc0|]d\t\xff\xf0\x7f\xbb}\xe5)\x00\xd8\xc1=/\
1b\xbb\xb0X\xc4#\x00\x00\x00\x00IEND\xaeB`\x82' 

def getNIBitmap():
    return BitmapFromImage(getNIImage())

def getNIImage():
    stream = cStringIO.StringIO(getNIData())
    return ImageFromStream(stream)

index.append('NI')
catalog['NI'] = ImageClass()
catalog['NI'].getData = getNIData
catalog['NI'].getImage = getNIImage
catalog['NI'].getBitmap = getNIBitmap


#----------------------------------------------------------------------
def getNLData():
    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\x00\xfdIDAT(\x91}\x8e\xcd*\x85a\x14\x85\xd7\xabOR\xe7\x8c$\t\xe1\x12\\\
\x81\xcb2\x90\x0b025t\r\xe6\xee\xe5$18EG\x94\xde\xbd~\x0c>\x0e\n\xab\xdd\xea\
i\xb7\xf6j\xb7\xe0K\xfe\xc9\xbfN\x0b\x80\xd3s\x00\xb1aA\n\r1\x14\xc8\x14C\
\xa5j\xf4\x97\xeb\xab\x01\x00\xc0\xdc=@\x82\x9c"T)\xa6\x98\xaat\xa6zz\xa5z\
\xdb\xdb10`\xf3(\xbb\xfbX\x9b@\x0e\t)T\xc8\x90\x1f0\x1e\x93\xd8\xda4\xd0\x16\
\x8b\xc5t:\x05\x90\x04A\x90\xbf\xd4Z\x9b\xcdf\x83\xed1\x9dd\t\xbf\n\xad\x91\
\x1c\xbc\x0c\xfd\xdf\x9f\xb4\x04@\xc3\xe1\xc5\xc9\xd9\xf1\xed\xfc\xb5h\xca\
\x9d*\xb9\xa8\xe2\xd2M\xba\xa4\x83\xad\xc9\xcd\xf9\xe5\x80\xfb\xe7\xa7\xd7>_\
\xbc\x15]r\xa7{\xa9\xa8N/\x9d4\xed\xc9\xfa*\xf08\xa0\xbb\xe4\xed\x8d\xf5\xb1\
\x89r\xc9\xa5\xb1\xd5\xa4\xe8H\x96-\x8d/\xe1\x14\xe8@\x07\xf8\r\xf8mC\xc0\
\x9f\xbe\xf2\x0e\xd9$jsT\xa0\xbcG\x00\x00\x00\x00IEND\xaeB`\x82' 

def getNLBitmap():
    return BitmapFromImage(getNLImage())

def getNLImage():
    stream = cStringIO.StringIO(getNLData())
    return ImageFromStream(stream)

index.append('NL')
catalog['NL'] = ImageClass()
catalog['NL'].getData = getNLData
catalog['NL'].getImage = getNLImage
catalog['NL'].getBitmap = getNLBitmap


#----------------------------------------------------------------------
def getNOData():
    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\x01ZIDAT(\x91m\x91\xb1jTa\x14\x84\xe7\xbf\xf7\xdaXH\x96\xd5b\x93\xac\
\x84\xd8X\x88\xa5\x8d\xe0K\xd8Y\x88`\x17L\x11\xb1\x93<\x81\x81<@\x1a\x8b\xb4\
\xc2\x92\xa7\x10\x02*B\xec\x8c+h\x88E\xb8\x10\xd2\xf8\xcf\x9c3\x16w\x17,2\
\xc5p\x8a\xc3\x9c3|\xe5\'\x16\xbak\xdf|\xf6\xf5\xea\xf0\xc1\xbcm\x13H\x00\
\xc00\xe8?\xef\x00\x8cv\xdf\x02\xb0\xbd\xf7b\xb5\x942~\xbd\xe3\x10$K\x16MYL\
\xca\xe4\xf7\xd9Q\x07\x00p\xfe\xfa\r\xe0O/\xdb\x9a\xcf-\x82L\xd2\xa4Y\xb3VW\
\xb6\xd3\xe9\xe2\x02\xc2V\x00\x88L\x00V5\xe5J\xb3\x9a5I\xd7\x9adC\n\xe8\xd6#\
J)\xc3K\n\xdb^\xf90\xf3u*\xa5\xdc\xbf\xbc,\xed\xd3\xcf\xfb/\xd7\xce{FZ\xb22\
\x15f\xa4\xc2T*\x92a\xc9\x8c\\\x1d\xdd8xu\\"b\x887\xfc\xe6\xfd\xd9\xbb\xe7\
\x93k\xe3m7M\xd3\xf7}w\xda\xb6\xb7\xb7\xb7t\xfacev\xc4\xb0\xed\x8b\'\x8f\xb3\
2I\xb0f\xe5\xa2\x06\xd5\xdd\xdb<9\xfe\xd4%`\xca\xa4mF\xda\xce\xbf\xc3F5\xe9\
\xcad5\x99\x11P\x08\xe8\x12\xb0\xd4L&\xb6\xef\xdc\xea\x00\xb4\xeb\xd3&\x98\
\x14\xc4\xa4Z)#\x10\x91\x11\x00\xca\xc9\x12\xe1F\xdf\x8f\x1e~\xbc\xf8\xf2\
\xe8\xdbx\xac%\xe3\x010\x96\x0e\xe0\x1f\xf4\x9eZ\x92\xf2p\xb7\x17\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getNOBitmap():
    return BitmapFromImage(getNOImage())

def getNOImage():
    stream = cStringIO.StringIO(getNOData())
    return ImageFromStream(stream)

index.append('NO')
catalog['NO'] = ImageClass()
catalog['NO'].getData = getNOData
catalog['NO'].getImage = getNOImage
catalog['NO'].getBitmap = getNOBitmap


#----------------------------------------------------------------------
def getNPData():
    return \
"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
\x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x017IDAT(\x91\x95\x90\xc1+\x83q\x1c\xc6?\xef\x10k\xd9f-i\xc4E\xad\xc5\x8988\
+\xc9EJN\x8e\xfe\x8c\xe5\xe0\xb2R\xeer\x94\x1c\x9c\x948Y8 \x07\xb9*5\x8c\xd5\
\xbb\xc2\xcbjz_\xef~\x8f\x9b63m\x9f\xdbsx>=\xdf\xafE\x15c\xa9K\xf3\xd2\xd9\r\
H\x0f7\xa3m\xb4\xcax\xea\\\x0e\xa8`Yf`\xe4\xa4\xd4L'P\x1d*\xa6\x84\x0f\xc4\
\xf3y\xebv7\x16\xeaO\xed\x97[\x12\x18\xf3A\xd4q\x90\xeb\xd2\x1e\x0cZ\xb9\xe3\
\x89`bx\xcboZ\xe0W^)g\xb3\x04\xc2a\x02\x91\x08\xf9D\x82\xc3\xbb\x95\xb6\xbe\
\xc1U5\x12X\xd5!9\xb4\xa6\xa3\x874\x06\x98\x9f>\xe0\xdd~\xa4\xec\xd8H.2\x1eo\
\x85\r\xeb\xb7\xa0\xbd:|Ul< \x9e\xc9\x90\xf5\xaeIn\x96x{^\xaf+5d\xb0oQ\xc5tZ\
\xee\xfd\xbd\xdc\\N\xb9\xb99\x85{\x97\x1b\xce\x87\xba\x1f\xd8T\x1c\x07|\x1f|\
\x9f\x8eX\x8c\x9d\xe26\xa1\xe8\xcc\xbf\x92\x1fzc\x93\xba\x00=--)\xbf\xb0\xa0\
3\xd0)h\x0f\xd4\xd5=\xf5\xa7\xa4\xe6\xbeP\xcf\xac\xa4/\x90\x87d\x90\x0c\xc8 \
\x01\x12\x92\xf0>\xafj:\xdf\xf3\xfb\x91\xc3\xc4\xf4\x81+\x00\x00\x00\x00IEND\
\xaeB`\x82" 

def getNPBitmap():
    return BitmapFromImage(getNPImage())

def getNPImage():
    stream = cStringIO.StringIO(getNPData())
    return ImageFromStream(stream)

index.append('NP')
catalog['NP'] = ImageClass()
catalog['NP'].getData = getNPData
catalog['NP'].getImage = getNPImage
catalog['NP'].getBitmap = getNPBitmap


#----------------------------------------------------------------------
def getNRData():
    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\x01QIDAT(\x91U\x911KW\x01\x14\xc5\xcf\xd37H\x10\xa2A\xf8\x07\x83tr\x08Z\
Z\x84\xa4/\xd0\x10\xb4\x06\xad\x0emM-\xae\xba\tN\xe1g\x90>D\xe4\xec\xe0\xe4\
\x10!%\x94\x11\x82b\xef\xbd{\xcf9\xd7\xe1\xf5\x97<\x9c\xe1\xc2\xfd]\xb8\x9c\
\xd3`\xf2\x16\xc4?\xd9\x08\x82D\x10\n\x80@\xfc\xe7\x1e`\x0bbk\xe7\r\x00\xcb.\
H\x92MY6iJI\x93J)\xa9O\xdb\x1fZ\x00\xa8:\xfb})\x97$j\\;\xa9[G2\xa9\xe5\x87\
\xf3@\xb40$PEY2\xe9\x90I'=\xa5\x95TP\x99\x02\xa2\xc5=\xce\xcep\x16Y\x8d\nU%\
\xcb\x92dI\xe4\xf8\xa0d\xd1E\xe0o\xfb\xed\xe3\xe7\xc5\xb5\x179\x9cS\x84\xd5@\
e\x96YN\x9be\xdaY\xa6\xcdvn\xe9dQ\xed\xca\xabg\xefw'\xdf\x7f\xce\xad?ytx|zy=\
D*\x93!e*(\x92\x99J\xea\xf1d\xe1\xcb>f\x90\xcc\xf4\xc6\xd3\xd5w\xaf\x9foo\
\xbe\x94\x9b\xaeg\x97\xd5\x0f\xee\xc3\xfd\xa0np\x17\xee\xc2A\x00h\x81 utr\
\xf6\xeb\xcf\xd5\xd7\x1f\xe7}?\xe44D\x92\x94HQ\x92mk<\xe8\x93\xae\x06{\x07\
\x87\x17W\xdd\xd2\x83\xfb\x94\x93\x9e\xa2\xa6\xc4\x11\x97\x004\xc0\xfa\xdd:\
\xc7Fo\xe7\xc2]\xdd\x00\x04-r\xbe9\x02\x8d\x9c\x00\x00\x00\x00IEND\xaeB`\x82\
" 

def getNRBitmap():
    return BitmapFromImage(getNRImage())

def getNRImage():
    stream = cStringIO.StringIO(getNRData())
    return ImageFromStream(stream)

index.append('NR')
catalog['NR'] = ImageClass()
catalog['NR'].getData = getNRData
catalog['NR'].getImage = getNRImage
catalog['NR'].getBitmap = getNRBitmap


#----------------------------------------------------------------------
def getNZData():
    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\xd8IDAT(\x91M\x91=kSa\x18\x86\xef\x9c\x9c$=\x874\xcdI\x93\xc6\x10k\
\xc1F1\x01\xb1\xfd\x01\x16\xc1I\xa5\xa0\xe8hGqp\x10W\x1d\xa4\x83\xbbc\xa1\
\x88\xd8\x82\xe8"*b\x05\x15,:\xe8P\xe8\x97E\x07\xfbA\xd3\xd0\x98\xc4\xc6\xa6\
\xc9I\xde\xe7y\xde\xd7! \xddn.\xaek\xba\x03\x9f\xefL\xbe\xdbO>x\xb4|?\xb5\
\x1a\xb6\xac{\xe5#7\x86\xf4\xc5s\'\xaf<)\x01-\x80\x01\x06\xda\x80\x02\x14`\
\x07N\xa7o\xcd=\x9f\xe0d\xba\xbd\xf6\x1d~\x0b\x99l,\x95x\xb3P]\\\xdf\'\xd2\
\xcc\xfa\xbc[\xfe\xd0\xe8o\xf8Ll^?\x9e\xb4g\xac\x17\xc1\xd5B\xe4o-\xb4W7~;\
\xe4\xc5\xdb\xa4\xcf\xfa\xeaUm\xd4\'3\xee\x14s\xcd\xdfu?>\xb5\x93\x1c\xcc\
\xc6\x01\xb6^\xba#\x94\xcb\x87\x87s\x14K\xe8\xa3C=#g\x0e\x12\x99\xa5\xd0\xb1\
\x0e\x1bE\xf2\xac\x96\xfaT\xef\x9b*\rLxE#\x02(\xab:v9\x10\x8d=\xddp\xb6\x02\
\xde\x16\xb93\xf5A;\x9f\xaf\x87cm%w\xbd\xb5\xa4\x83\xd9\xca\xc05w\xf3\x84\
\xa9]\x88\x14\x01\x15<\xd5\xf0v\x9d\xd4\x97\xe5?\xbe\xdfY\xaf\xd2\xc7o;+\xbb\
\x92\xea\x91\xc52\x8f;\xdb\x05S\x99\xdb\xf3\x16\x1an\xbfn\xbe5\xc3\xdb?\xde\
\xdb\xb3\xbf\xec\xdb\xc18\xc7\xf0\x95{\x99\x84\xfa\xf8g\x85VJ\xa2\xc8\xdc\
\xdc,(b"V$\xd3~\xf6\xb8#\x80\xb2\x00&\xd2J4\x93\x10\x89R\xbaCF\x91\xeezDZ\
\x91\\\x8fn0\x89\xb0\x06\x94\r0\xb3\x90\x12b\xe9J\x8a\x84\x94\xa8n\xcf\xfc0\
\xbd\xe4\xe9f\xa7\xb73/\xa3\xdd\xa0El2\xe9(\x910\x0b\xb3&\x16ba\x12b\xcd,\
\xd3\xa1\xb1K\x91\xe2\xbcN\x8b\x18@\x02\xc0U\xe0\xe0\xd0\x97\n\xe0C\xfb?a@\
\x03\xee?\xf8\x90:\xacV7\nv\x00\x00\x00\x00IEND\xaeB`\x82' 

def getNZBitmap():
    return BitmapFromImage(getNZImage())

def getNZImage():
    stream = cStringIO.StringIO(getNZData())
    return ImageFromStream(stream)

index.append('NZ')
catalog['NZ'] = ImageClass()
catalog['NZ'].getData = getNZData
catalog['NZ'].getImage = getNZImage
catalog['NZ'].getBitmap = getNZBitmap


#----------------------------------------------------------------------
def getOMData():
    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\x1aIDAT(\x91u\x8d=JC\x01\x10\x84\xe7\xc5\xa7\x82\xf8\xd3\t\x82\x10\
\x88\x1e\xc0V\xd0cx\x00=\x83\xa4N\xe7il\xd3\xc6\x1c\xc0\xdc\xc0&E,M\x1a\xc1\
\x9d\xd9Y\x8b\x17\xffP\xbfbf\x96\x9de\x9b\t~p\xf6\xb2\x02l\x1b\x9d\xfd\xa2\
\x05p\xb9\\\xbe\xcef;\xe7\xe7\xcf\xa3\xd1\xc1\xc1^\x15\x80\xaaO\xfb\xc6b\xb1\
h\x01\xe4j\xb5{q\xf1\xf6\xf4\x14\xf3\xf9\x9f\xbd\x8e\xa6i$\xf5\x00l\x1c\x1e.\
\xc7\xe3\xad\xc1\xc0\xe4\x7f\xed\x0e\xdb\xcd\x048\x1d\x0e\xdf\xe6\xf3\x92\
\x8aJ\xb1H\x93\x0e\x16\xc3\x11&+\xc2\xe4v\xbf\xff0\x9d\xb6\x06JYdI\xa6 "\x02\
$\xc8\x8a\xa8N\xbb \x01h\x05T\xaa$3L\xf5\xc8b \xd8D4\\ku\x99\xec\xad\x0fHGX\
\xaa\x88\x9b[F\x06\x93\xf4:\x84\x83\xa6R\'\xfbz\xbcC\x0b\xc0\x92I\x93EF\xc6W\
/\x19I:d\xca\xa9Lx\xfdA\x9bGGEZy\xbcC\x9aL\xca\xa2)K\xa5\xccLg"!4\xf7\x80\
\x00\x01\x06\x04\\_\x01\x01\x08x\x05\x0c\xf8c\xec\xd6\xc0;\xbc\xecyx\xe0\xb6\
\xdf\x86\x00\x00\x00\x00IEND\xaeB`\x82' 

def getOMBitmap():
    return BitmapFromImage(getOMImage())

def getOMImage():
    stream = cStringIO.StringIO(getOMData())
    return ImageFromStream(stream)

index.append('OM')
catalog['OM'] = ImageClass()
catalog['OM'].getData = getOMData
catalog['OM'].getImage = getOMImage
catalog['OM'].getBitmap = getOMBitmap


#----------------------------------------------------------------------
def getPAData():
    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\x01MIDAT(\x91U\x90\xbdJ\xdcQ\x14\xc4\xe7^\xff)\x02q\x9b\x85\x85\x08bae\
\xc0\xd6V\x10,\xac\xed\xf3\x0c\xb6\xb1L-b\xe9C\x04\x05{!>\x81\x95l\x13\x88\
\x85Z(\x06w\xd5\xe0\x9e\x8f\x19\x8b\xeb.:\x1c\x0eS\xfc\xceg\x19\x8dFx\'\x12\
\x00I\xa2\xdf\'\xd0"\xa6\x86@\x07\xa0\xd7\xeb\x01\xf8\xf7_$\xfa\xf3\x90\x00\
\xc8vv\xf8\xfc,wE\xcc\xf2\xdd\xc9I\xd7\x1a\xdf\x8c\xf5\xeb<\x9f&\xfa\xbeV\
\x17zER\xfe\xbd\xe4\xe3X\xe6t\x93\x99\xdc\xeb\xe2b\xb4\t\x92\xbe\xcecu\x01O\
\x93\xd2hI\x8d\xa3\x9b\xcc[\x01\xdd\xdfVjZ_\xae\x104\xd3hL7\x9a\xc9]ft\x9fs\
\x0f\xa0\xfb\xb6\xdf\xfd\xdc\x8a\xdbGe*\xa8H\x04\x85\x88\xdd\x8d\x8d\xeaV"\
\x94\xa9\x88\xea^\x06\x83\xee\xec\xac\xbb\xfe\xc3\x9b\x07]=\xc8SAy\xcaS\x1e\
\xe5\xd3\xee\x0f}T\xad5\xb6\xb7+\x8cAL9y\xe8e"O\xce8;<\xb4\x83\x83v*\xc9\n\
\x9b\xd2)Ky*E\x8f7:\x87C?=\xf5\xe3\xa3\xbc\xb8\x90\x14\x11\x1d\x82I\r\xbe\
\x94H8\x11\xa9`\x89,\xa5\x14\x00s++\x9f\xf7\xf6@bi\xa9\xfd\xa6`\xf3\x1eF\xbc\
\x10\x160N=\x87\xbf-"H\x92\x04\x19d+x\x05?y]\n-\x0c\xc2^\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getPABitmap():
    return BitmapFromImage(getPAImage())

def getPAImage():
    stream = cStringIO.StringIO(getPAData())
    return ImageFromStream(stream)

index.append('PA')
catalog['PA'] = ImageClass()
catalog['PA'].getData = getPAData
catalog['PA'].getImage = getPAImage
catalog['PA'].getBitmap = getPABitmap


#----------------------------------------------------------------------
def getPEData():
    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\x00\xcfIDAT(\x91\x85\x91\xcdm\x821\x10D\x9f\xe1\xeb\x01q\xe0\x00}\xd0\t\
\x9d\xd0\x15\x8dP\x00\xd7D4\x90\\\xbc\xb3;9\xf8\x0b\x7fB\xc9h\x0f\x96<O\x1e\
\xef4sW\x01\xd7+U@\xdd\xb4\xdd\x16\xdcf\x028\x1e\x01W\xb5*V+\x1bp\xb3\x97\
\xb0\xb0}88\xc2\x92#\xbeN\xa7\t\x00\xfb\xe3\x93L2=\xec\x8f\xba\\\xdc\xbb#\
\xdaf3\xbf\xe0\xf2\xec\x8exu\xdb\xee}\x00D\x14L\x05-\x13\xc9\x12\xa1W\xf73\
\xc0\xfc\x07\xe5H\xf9\x0f \xfdFJYr\xf4\xbf\x81v\x8f\x14\xe1\xde\x91\xdc\xfb{\
 bd\xd6\x00\x96\xd2\x88\xe8\x88\xf7\x80\x02%\x99\x0c`\x11b\xbdv\x04\xca\xd1`\
k\xed^\xe7n7vHfA\xfb~h\xb1\x80\xf3y.X\x9a\x0f\xfb\xfd|\x05\xc0\x0f\x02=a\x84\
\xb72\xeb\xb6\x00\x00\x00\x00IEND\xaeB`\x82' 

def getPEBitmap():
    return BitmapFromImage(getPEImage())

def getPEImage():
    stream = cStringIO.StringIO(getPEData())
    return ImageFromStream(stream)

index.append('PE')
catalog['PE'] = ImageClass()
catalog['PE'].getData = getPEData
catalog['PE'].getImage = getPEImage
catalog['PE'].getBitmap = getPEBitmap


#----------------------------------------------------------------------
def getPHData():
    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\x01qIDAT(\x91e\x91\xb1k\x93\x01\x14\xc4/_?\xb5\xf8Y\xc9P35K\x15\x84\xb6\
\xa0\x88\xe0\xd8\x7f\xa0\x8bvu\xed\xea\xd4\xbdC\xff\x01\xa1BD\x05\x07\x11+\
\xa4 \x11\xda\xd9\xa9\x14\xa1:9T\xb0\x8a..\x89\xa0&\xe6\xbd{\xef\x1c\xbe*A\
\x8f\xe3\xb8\xe1w\xd35vv:\xab\xabC\xe0\x07\x00 \x81\x04\x08\x10H\xc0\x00\x02\
6Y\x1a\xd2\x8d~\xffQ\xafw\xe6\xe8h\x90\xa9\x08\x91\x19\x91\xa4\xc8\xa4\xa73\
\xe8\xe9L\xf7\xe8\xf5\xb6\x1a\xa3\xd1\xd7\xe9\xe9V\x84vw\xbft\xbb\xef\x87C\
\x8b\x80\xbb\xdc\xd3=\xdc\xc2<\xcc\xd2=\xda\xedjo\xefn\x01\x9c\x97\x86E\xf1a\
e\xe5\xd4\xfa\xfaB\xbb=c&\xf7p\xa3\x9d\xd0aF3\xba\'`Ef\x02\x9f\x81\x8e\xd4Y\
\\\x98\xda\xd8\xb8\xbe\xb44c\x16cK\xb3\x18\x8f\xebA\x98E=(\x81\xef\xc0\'\xe9\
\xa3t\x168\xae\xaa\xab\x9b\x9b\xdb\xdd\xad\xc5\xc3\xe7\x03Z\xd0\xe9\x164\xd2\
\xd9\xe2\x85Wx]\x02\x954\']\x12Z\xd0E\x8d\xc6z2\x7fk\xfb\xf1M3\xb9k"\x0b\x9f\
\xbf\x03\x94\x99\x90\xe6\xa4\xdb@S\xef\x8eu\xef\xa1\xde\x1c\xca\xfd\x1f\x1a\
\xa4H\x02e\xe6O`V\xba\x8c\x17/\xf5\xe0\xbe\xbe\r&\xb9\x93B\x07\x03\x11\x00\
\xca\xcck\xea?\xc3\xd3\xb7:\xd8G\xb3\x89s\x15\xdc\x1b\xee Q\'\x89\x88\xda\t\
\x94\xa7\xbbW~\xad-\xe7\x9f\x93\xff\xbe\xfd\xbfk\xfd\x067!U\xfbOY\xcaK\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getPHBitmap():
    return BitmapFromImage(getPHImage())

def getPHImage():
    stream = cStringIO.StringIO(getPHData())
    return ImageFromStream(stream)

index.append('PH')
catalog['PH'] = ImageClass()
catalog['PH'].getData = getPHData
catalog['PH'].getImage = getPHImage
catalog['PH'].getBitmap = getPHBitmap


#----------------------------------------------------------------------
def getPKData():
    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\x8dIDAT(\x91eQ\xcdJ[a\x14\x9c\x9b{\xbd\x90&\x11i\x17%M\x04\x0b\x9a"\
\xdd\xd8\xad\x15\xea\x03\xf8\x08\xe2\x0b\xb8\xad\xdbf\xe9\xdaM\xe9[(Y)\xb8sU\
\xe8\xcf\xd6E\xc5\xd4\xc4J\xa5Tb\x92&\xdf\x9c\x9f\xaf\x8b\xabT\xe8Y\x1c\xceb\
f83\x93\x0c\xc2\x00\x00\x80\x11G\x8d\xf7\r\x8c\x00\x07\x14P\xc0\x01\x02\n\
\xf0\xfe\xc8\x90\x01\x98\xcdg\x01\xe4i\xde~\xd3\x1e\xcbXa\xe6\xaa\xa6\nU\x13\
qU\x131\x15\x97\xce\x87NV\xc8\xc7\x18\xdd\xbd7\xee\xdd\x86[s\x8b\x88\x8dJ\
\xf3\xfb\xcd\xd9\xc4&\x14\xd2).\xf3\xd5y\x10\xa5\x02]lu57*\xb7_n\xaf=}=\t\
\x93,\xc9vVv\xea\xe5:\x95\xe2\x02E\t\xf7\x13\x11\xd5\x95\xca\xd5\xfajk\xaeu\
\xd8;\n\x1e\x9a\x95\xe6\xf2\xe3\xe5\xcd\x17\x9bT\x8a\t\x88\xcc\xdd\x0b\xf9\
\x18\xa3\x98\x88Hm\xa6VN\xcb?F\x974~\xbe\xfe\xb2\xfbi\xf7bx\xc1H\x8d\n\xa2\
\xe4~\x87.\x08\x8c\xbc\xfe\xf33O\xf3\xad\xd6\x16\x03\x19\xc2I\xff\xa4;\xec\
\x8a\x8b\x98@\x91\xc1\xfd\x01\x81t\x1ev\x8fV\x9e\xbc\xdax\xbe1\x08\x83!\x87\
\x0b\xb5\x85\x83o\x07\xc7\xfdcs\x85"s\xfc{\x89.42\xb2\xfd\xf1]\x7f\xd8_\x7f\
\xb6^\xcd\xab{_\xf7N\x7f\x9fNm\xaafw\x1e\x8a\x94\x92$\xa9W\xea\x95\xb4"Q\xc4\
\xa4s\xd6\xd9?\xdf7\xb7 !\x9dI\x17\xe7\x16-\x1a\x14\xc9\xd5\xcd\x95\xbb\xbb\
\xfbT\xa7Ko\x97\xf0\xeb\xbf\x82\x1f\x16\xff\x08\x7f\x01\x87\xca@\x8cM\x0b%\
\xe5\x00\x00\x00\x00IEND\xaeB`\x82' 

def getPKBitmap():
    return BitmapFromImage(getPKImage())

def getPKImage():
    stream = cStringIO.StringIO(getPKData())
    return ImageFromStream(stream)

index.append('PK')
catalog['PK'] = ImageClass()
catalog['PK'].getData = getPKData
catalog['PK'].getImage = getPKImage
catalog['PK'].getBitmap = getPKBitmap


#----------------------------------------------------------------------
def getPLData():
    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\x00\xbaIDAT(\x91\x8d\x8d1nBA\x0cD\x9fakz\xc4\x9d\xb9\x037\x83\xe6\xf7\
\xa0\xa4\xd9\xf1zRl\xf2\xc5\x0fD\xcahl\xd9\xf2\x1b9|\xbf\xf3\xa3Z\xab\xaa\
\xa0\xde\xa9\x01\x1c\x0e\x80\xed\x00\xc0\x06\x1c\xf6\x1ev\xde\xe8cY\x1a\xdf\
\x90\x9f\x07\xbfSDTf\xfb'=OU\xd5\nb\xa5\x8d\xff\xe4\rP\x15\x03\xe2|\xf6\xb28\
\x93L\xaf\x96\xact\xca\x92%g\xc6\xe9t\xbf\\\x1a\xe0\xdb\xcd\xd7\xab\xd5\xd1\
\xe4\xba\xbb\xdc\xbb\xb5\xe9\xf1x\x14\xb4\x82\x90\xdc;\x99\x1bhK\xcf\xe79\
\x03\xfbLK\xac\xd0k,E\x0e\xc6`\x06vJ\x8eGK\xe4 \x85\x14\x12\x99\xcc\x9e\xc9\
\x18\xd3\x05\xf1\t\xf5d\xb6\xeb\xaf\x13\xf0\x05\xc2\x7f]y\xc1\x7f\x96\x92\
\x00\x00\x00\x00IEND\xaeB`\x82" 

def getPLBitmap():
    return BitmapFromImage(getPLImage())

def getPLImage():
    stream = cStringIO.StringIO(getPLData())
    return ImageFromStream(stream)

index.append('PL')
catalog['PL'] = ImageClass()
catalog['PL'].getData = getPLData
catalog['PL'].getImage = getPLImage
catalog['PL'].getBitmap = getPLBitmap


#----------------------------------------------------------------------
def getPRData():
    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\x8bIDAT(\x91m\x91\xcfK\x94a\x14\x85\xcf\xfb\xbd\xaf\xe3\x8f\x99\xc1\
\x8d\x89\x90ZH\x04\xa5`\x88\xe6\xbe\xfe\x81\xfe\x80 \x82V\x82P\xdb\x86\x16\
\xad\x15\xdc\xb5m\xd1\xc66\xb3\x125\n\\L\x8a\x8b\x90\xa1\x854.\n\x86\x9a\x85\
\x88\x85\xe07\xf3}\xf7\xbe\xf7\xb8\x185\x17\x1e\x9e\xc5\xdd\\x\x0e\xc7\x01\
\x8d\x0fx0\x85v\x07\xc8\x01\xbb\x82\x02\n\xe0\xe2P \x01\x02p\xb7Y9\x1aBm*\
\xd9\xedq\x99d\x91jT\xb1\x18\xa9\xda\xc5DL\x84\xaa\xbb\xd5\xaa\x03\xf8\xa6\
\x82\xe6o\xde.\x1d\xbe\xaa\x0c\x94\x87zi$@\x12\xbcH\x92\x90\x84\xd9\xdf\x83\
\x83\x04\x80\x1a\xcb\xfdh\x1c\x0f/\xbe.6\xff\x84\x98\x04x\x0f\xefy\t@\x00\
\xde[\x08\x0e\x88++\xee\xf1#l}\xe1^\x1dG\xc7|6V\x9d8\xa9\x95\xe5\x90\x92\x9d\
\xcb\x88\x98Hattgu5\x00x8\x8b{\xf7Y\x1c`\xed+L\xf8\xee\xc7\x93\xa7\xb11\x93}\
\xf3y\xbb#bynyn"}d\x0b\x08\x00>m0F\xae\xaf1=E;\xe7\x8b[\x1fgK\xff\xbcNS\xa5W\
\xc4\xba\xbdc\xec\x19\x19\x19\xdf\xdev\x80\xbc\\p\x8d_TE_?\x97\x9686\xce\xe4\
\x7f\xdf\xf3\x00p\xce\xb5\xf6\xf7\x03`\x1d\xf5"\xbcSn\xbd].\r\xde,\x92\xa4\
\xd1TI\xd2\x8c@\xf7\xdd9\x874u@{\xf1y6\xaf\x1bs\xf8\\\xc0i\x96\xaau5.eT\xa9\
\xd1,"\xc6\xcdz=\x00?\x87\xdfO\xde\x00\xbe\x03\xe9\x95\x81\xf3\xeb\xf6.\x00g\
\x9eG,\x0f\xd3,\xbc\x95\x00\x00\x00\x00IEND\xaeB`\x82' 

def getPRBitmap():
    return BitmapFromImage(getPRImage())

def getPRImage():
    stream = cStringIO.StringIO(getPRData())
    return ImageFromStream(stream)

index.append('PR')
catalog['PR'] = ImageClass()
catalog['PR'].getData = getPRData
catalog['PR'].getImage = getPRImage
catalog['PR'].getBitmap = getPRBitmap


#----------------------------------------------------------------------
def getPTData():
    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^IDAT(\x91m\x911k\x93a\x14\x85\xcf\xf7\xe6mR+\xa5B:\xd8!\x82\x83"\
\xe2\xa4\xfe\x03\x9d\xdc:\xbat\xeb \x9d\x9c3v)\x88\xbf@\xdc\x04g\x0b\n\xfe\
\x01A\xf4\x0f\xe8\xa0K\x9d\xa2i\x89\x89\xe9w\xcf\xb9\xf7:$\xa1K\x0f\x0f\x973\
\xdc\x87;\xdc\x06O\x81)\x96\t\xa0\xc2\xdf-\xeb\xa5TL0\xdc\x1f\x02\x88\x88\
\xc8\xf0\xc6q\xd3\xe1j\xa4\x8eT\xc8\x94r5\xa7\xc7\xc7\x15\x05@\x9e\x9c\xfe\
\xda\xe8\xf8\xfd\xbe\xdf\xebS\xbb\xae\x11\xbbo\x99\xa7Lc\xd2\xd2,\xc9f0\x08\
\xa0\x02\x88H\x0f\x7f\xfe\xd0\xb7Zu\xdf8\xe7\xcc\xc7\x9c\xeeq\xe3\x85%-\x8d\
\x0b\x01d\x00\x05\x01O\x97t6\xe3\xfa{u\x0f\x0e\'\xcf\x8e\xec\xcbv\xd3\xa3`\
\xd9Z\xda\n\x12@\x81A\xeetVp>\xb3\xb6\\9\xbb~\xbb-kQZ\xaeY\x92\x17\x82\x14@\
\x85\xc1C\n}\x1d\xd9\xadG~\xe7\xd5p\xfb\xea\x8d\xf9\xee7K\xeb\x8f-\xdb\x95C6\
d\x00\x15\x02\x9d\xe6\xf6\xf1\x87\xfaw9yrr\xed\xcf\xcf\xeewv>Y\x99]lCJI\x8b\
\x0b\n\xd1\xf9[|\xf9\x99\xbdM\xfb\xf0\xda\xd4c\x19[\x92KA\x84\x1c\xee\x00*\
\xfe\x81\xd2\xce\xd6\x0eE\xb9+\x89\x01+\x99\x9b\x02\t\t\x12\xdc\x17\x04\xd0\
\xe0\x010\x06\xce\x01\x03\xce\x81\x82\xd1\xdf\xcb\x7f\xbc\xc8\x7f\x8e\xd7Fv\
\x05\x02MO\x00\x00\x00\x00IEND\xaeB`\x82' 

def getPTBitmap():
    return BitmapFromImage(getPTImage())

def getPTImage():
    stream = cStringIO.StringIO(getPTData())
    return ImageFromStream(stream)

index.append('PT')
catalog['PT'] = ImageClass()
catalog['PT'].getData = getPTData
catalog['PT'].getImage = getPTImage
catalog['PT'].getBitmap = getPTBitmap


#----------------------------------------------------------------------
def getPYData():
    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\x1fIDAT(\x91mR;J\x04A\x14\xac\x9e\x19\x075\x11\xc1@\x84\xdd\x0bx\
\x0cS\x03\xf18n``b\xe8-D\x10\x83\xc5\x1b\x18\x8a\x81W\xf0\x83,\xac\xff]\xd4\
\xe9zU\x06\xe3\xfe\xc0\xe2QT?\xea\x15\xdd\xf4K\xc6\x0cZ\xd4\xffV2\x80^\x0f\
\x80%H\x880\x03A\x93 \x9d\xb3\xe7x\xd4\xefW\x00\x00\xfb\xe1\x11\x11\x88p\xce\
-\xffU\x93\x9d\x1b7\x8dsN\x9d\x8e\x80\n\xe3\xb1\xeb\x1a\x12\x00\xdb\xf0\x14\
\x98\x1d$\xdb(\n\r\x87\xd5\x9b\xea\xb5\xb2DY\xfeY`\xdd\xdd\xfd\\^(\xe7zw\x1f\
\xdd\xee, \xa5aS\x17\xedK\xa7\xa1\xb6=\xfa8\xdd~9\x1c\xed\xf8\xf3\xd5\xf3\
\x00H\x15\x92\x16\xdc6V\x96\xf7\xae|\xf0}\x86\xe5\x95\x05\xbf\r)=\xbf\x7f\
\xad\xd6K!\xb5\x13\x9a\\\x1fVx\xd2\x90eTe\xf1\xf04HX\xbf=:\xde\xba\x1fdR\x99\
 \x95iRy&L)\xe8\xeef}~r]\xa1\x11\xc3\x1b\xebE\xb0`\x98Q\x90\x8aH\x8c\x92\x14\
\xc3\x11\xa2\xa00-\x00\t\xe5\r\x82\x80\x80yn\x05\xe7\xbe\x98\xed\x06\xfc\x02\
o\xefV\xf1,"\x04\xa3\x00\x00\x00\x00IEND\xaeB`\x82' 

def getPYBitmap():
    return BitmapFromImage(getPYImage())

def getPYImage():
    stream = cStringIO.StringIO(getPYData())
    return ImageFromStream(stream)

index.append('PY')
catalog['PY'] = ImageClass()
catalog['PY'].getData = getPYData
catalog['PY'].getImage = getPYImage
catalog['PY'].getBitmap = getPYBitmap


#----------------------------------------------------------------------
def getQAData():
    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$IDAT(\x91}\x90\xcf*\x85Q\x14\xc5\xd7\xbd}\x19\xdcd`\xa4\x90\x97\xf0\
.\x94\x94\x8cL\x94\x81(\xa2\xc8@)L\x8d\x0c\x0c\x98x\x0f#^Af\x92\x7f\xe9\x96\
\xbb\xd7\xda\xeb\x18\x9c{?FV\xbb38\xfb\xb7\xd7Y\xfbt\x06\xfd\xbe1\x94\xe1\
\xd5\xa9\xc9\xfb/\n\x08\xe0{t\x12\xbf\xea\x0c\xfa\xfd\xb1^\x0f@)\xa5^]\xedng\
\xd2\x99\xa9L2%\x91)Y\xdc\xba\xbem\xaa}K\xdf\x1c\xee\xbf<=\xa6$J\x8c$E\x8a!r\
rz\x06@\xf7/m{a\xef@\xaaD\x88$C\x0cF0\xc2"\x80\xa6\rW\xc7\xaev\xb6\x92T\x84\
\xa8\xd6[\x11"\x93\x02\xd0\xb5]\xe9:\xb0tt\\\xdb\xe2@\x11\x8c!\xcd\x08\x91\
\x00\x1a\xdbe\x88\x97\xe2r\xb9\xb9A\x86\xe27\xbaH\x05M\xa6\x08\xa0\xeb\xd6\
\xbe\xa0\x94\xb2rr\xa6\x081\x14\xb58z\x90\x99\x02\xd0`\x14\xa9nr\xb1\xbe\xa6\
h\xa3S\xa4D\x93J\xa5\x0c\xa0\xf3\xf9\xfe\xda\x1b\x9fhw(\xa5\x9c./\xa6(\xd5\
\xbf\xcf\x94\x9c\xcaLg\x9e\xdf=4\xb6?\xde\xdel\xdb\x965?;\xf7\x8c\xff\xf4\
\x03k}[\xe5\x9e\xcb>\x13\x00\x00\x00\x00IEND\xaeB`\x82' 

def getQABitmap():
    return BitmapFromImage(getQAImage())

def getQAImage():
    stream = cStringIO.StringIO(getQAData())
    return ImageFromStream(stream)

index.append('QA')
catalog['QA'] = ImageClass()
catalog['QA'].getData = getQAData
catalog['QA'].getImage = getQAImage
catalog['QA'].getBitmap = getQABitmap


#----------------------------------------------------------------------
def getROData():
    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\x14IDAT(\x91]\x911J]a\x10\x85\xbf{\xf3?Iz\x9b \x16\xda\xba\x00\x17\
\x92\xc2&\x0b\t\xd8eI\x0fR\x06\xec\\\x84\x9d\x08\x16\x81\x18\x82\xa8o\xe6\
\xcc\x9c\x14\xf7\x06\x9f\x0e\xa7\xfd\xe6|p&\xce\xae\xf9+\x00f\x18\x0fW\xe7\
\x1f\x0f\xa0\xe9\xa6\x9b\xf1B\x9f\xd1\xbcf\xf0[\x97\xdfO\x80\xee\xa9=\x7f:\
\xfa\xb6\xd9\xec@\xb6@~L\x7f\x953-9\xf3q\xbb\x1d\x0c0w\xbf\xb2\xda\xd5s\xf7-\
<\xdb\xb9F\xe9\x9bp\x843\xa7\xe3\xe3\x86\x01\xb4\xa9\xb6\xca*\xdb\xb2\xc3\
\x96\x9dv\xb8\xc3\x91\x0b@f\xc3@]mUK\xa8l\xc7\xeb{\x87\xfd\x06\x00\x06\xd1*\
\xa7\xfc\x1f\xc8=&\xect\xacJH\xbd\x00U-9d\x15{@\xd8\xb9\xaf4\xadJ\xd1Y\x84Zr\
\x8aU\xe3]C&\x92%\xc1`'\xa93;\xe5\xaci\x0fX\x1a\xd2\x11V\xa2\xa2\n\x18\xa0\
\x94?\x1fnRV}\x98\xe7#x\x9a\xa6\x04A2\xc4\xa9\xa8Z\xd20\xc1\x0f\x08\xd0\xb2\
\xe3\xfd\xcf/c\xd0\xa2\xa1E\xff\xa1/\xd6\x8d\x97\xfb\x07'\xado\x9d\xaf7f\x92\
\x00\x00\x00\x00IEND\xaeB`\x82" 

def getROBitmap():
    return BitmapFromImage(getROImage())

def getROImage():
    stream = cStringIO.StringIO(getROData())
    return ImageFromStream(stream)

index.append('RO')
catalog['RO'] = ImageClass()
catalog['RO'].getData = getROData
catalog['RO'].getImage = getROImage
catalog['RO'].getBitmap = getROBitmap


#----------------------------------------------------------------------
def getRSData():
    return \
"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x11\x00\x00\x00\x0b\x08\x06\
\x00\x00\x00\x99 f\x07\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x01'IDAT(\x91\x9d\x91\xbdJ\xc3`\x14\x86\xdf$_C\x9a\x984E\xab\xc1A\rEQ\xc9\
\xe2\xe0\xe05\x88\xa3\x93\x8b\x827\xe1e\x88\x83\x9b\xae^\x85\x93\xf0!B\xa7\
\x06\x1c,U,\xda\x14\x0bI%6i\x93|.\x1a4\xa5M\xf5\x19\xdf\xc3y8?\xdc\xc9\xea:3\
e\x05\xff\xa5\xf9\xe1\x83\x98\xb2\x02K+\xfd*\x84$\xc1\x90D\x98\t\xc4\xa9D$\
\x1b<\xe8@\xb8\xd2\x03_\xe4 4$\xacu\x92|\xc9U\xa4\xd6g\x87\xfa\xfbw\xb0\xbbT\
5\xe7\xcb\xdd28\xc05\xf4\xdey\xa7\xd5\x0c\x86Q<N\xd0\x8d\x12\x95\\\x1b;\x16\
\xe6\xaaix`\xba\xf0^=0\xf0\xd0\xcc\x85\xca]\x7f\xa3r\xefs\xe3\xc7xk\x80\xcff\
\xbe\xae\x83\x0bE(q\x11\x03c1w\x15\x00\xa3\x12\xdei\xa3\x00@\x94$\xc4/-\x04\
\xc9\x84)\xbe \xfb\x9bb\xddX\x96\xd2\x9b\xf0\xcf\xb5m_\x90I\x9f\tP\x1ei\xb2g\
\x1d\xdfN\x12\xb4\x9fD\x15\x94R\xf6\x93\x81\xeb\xb1\xda\xc5%\xbb9=c\x81\xe3\
\xb0<(\xa5l\xe4\xc5\x85\x92\x86\xad\xa3\xc3\xa9n\x91\xaec\xdb\xf6\x9f\x1a\
\xb2\xd8\xb6\x8dO>1\x8eT\x1c4\xb0\xeb\x00\x00\x00\x00IEND\xaeB`\x82" 

def getRSBitmap():
    return BitmapFromImage(getRSImage())

def getRSImage():
    stream = cStringIO.StringIO(getRSData())
    return ImageFromStream(stream)

index.append('RS')
catalog['RS'] = ImageClass()
catalog['RS'].getData = getRSData
catalog['RS'].getImage = getRSImage
catalog['RS'].getBitmap = getRSBitmap


#----------------------------------------------------------------------
def getRUData():
    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\x00\xf2IDAT(\x91m\x8f=N\xc2Q\x10\xc4\x7f\x0f\xfe\x15v4\x86X\xd0\xd8Xx\r\
\x13nB\xcb=<\x85W\xa0\xe0.\x16\x16\x14\x86\x8e\x98HL\xde\xcc\xdb\xb5xD>d\xb2\
\xd9\x9d\xdd\xd9\x8fl9\x1c\x92\x13"\xa2\x87\xce\xe2\n\x0e\x06`2\x01\xc8L(@f\
\xcf\n\x8c3Gy\x86\xdd\xee{\xe8\x9b3\xf3\x9c\xe4-\x94R"\xa2,\x16\xb9\\\xe6~O\
\x04\xadekDdki_x;\xa7\xd3\xb2Z}\r\x9bM<?\x97\xed\x16;-\xe4\x94R\xcaZ\xaf\xfd\
|\x0e0\x006R\xfe\rt\xb9\xf7U\xa5\xea\xb1b\x17\x88\x01\xe8G\xab\xd2\xe2\xd4\
\xfa\xef\x82\x94\x10\xc3\x9a\xf1\x93^\x7f\xeag\xd8Y\x1drT\x85\x1c\xd2\x91T7)\
\xdc\xee\xfc\xb0\xe6mx\x81\xb1\xdfC\x1f\xb7\x97wb\xe1V\xda\xe3=\x0c\x01#\x99\
\xd9,%\xdc\xb0\x90\x8a\xd4?\xc3\xc6\xa6\xb5n\x01\xe5\x00qf\\\xa6W\x12\xf0\
\x0b?\x89e\x1eo\xd1Q\x86\x00\x00\x00\x00IEND\xaeB`\x82' 

def getRUBitmap():
    return BitmapFromImage(getRUImage())

def getRUImage():
    stream = cStringIO.StringIO(getRUData())
    return ImageFromStream(stream)

index.append('RU')
catalog['RU'] = ImageClass()
catalog['RU'].getData = getRUData
catalog['RU'].getImage = getRUImage
catalog['RU'].getBitmap = getRUBitmap


#----------------------------------------------------------------------
def getRWData():
    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\x01EIDAT(\x91m\x8c1\x8a\x94Q\x10\x84\xeb\xbd\xff\xcd\x82\xb2*\xc8l\xb0\
\x91\xe0e\x043\x83=\x81\x08\x06bd"\x82\x81\xe0\x9a\x19\xe8\x01\xcc\xf4\x10"x\
\r1\x11A\x1cW7\x19u\x1c\xbb\xab\xab\x0c~\x06v\xc1\xa6)\xaa\xa0\xbej\x97\x9e:\
\x84\xf9(\x15\x01\x01\x04(H\x08\x81B\xec\x8c0Bx~\x03\x00l\x97\x9b\x0c\t%\x97\
[iJu\x8bG\xcb\x17\xcd\xf1\xfa\xeb\xbd\xe3\x97\x1a\xf3\xf6\xc9o\x97!\x81r\x15\
h\xb3Ly\x9b\xbes\xf8d?>tm\x8e\x96q\x8c\xfb]\x80\xe5\x12J\xa0\xccB\xdaYf9\xcb\
\x94\xdf\xac\xee\xfea\xff\x16\x07oOo!42D\xb7(\x94<3%Wy\xbbc\xbe\xc4\xc1\xa3\
\x8f\xaf(/\xf7\'\xac\xd7\xed\xe7_,\xa6\x87\xd6g\x83v\xda\xb4\xc3N8\xed\x94c\
\x8e6[\xbf\xb6\xfa\xfen\\\x1c\x006\xee\xbf\x8c\x80g&\xfe\xab\xbd_\xbd\xbc\
\x87!\xa1\xb5\xb4\x03\xe0\xf9\xd2\xb96@\x9b$\xc6\xe21\x1e\xdc\xe4\xa7u\xa62+\
\xb3"\x14\xb3\xc9J:\xb3\x82\x95\xa9\xba~\xa5\xde?\xc3\xc0\tN\xb7\xbc0\x0e\
\x87r\xd1\x8a=\xf7*\xb3\';sJ\x169\xb1TU\xf5cSX\xa1\xe16\xb0\x05\xe2\xcc\xf3\
\x8c\x06\xa0]\x140\xf0\x0f\xf8\xb9h\xc1\xd7\xfaS\xe0\x00\x00\x00\x00IEND\xae\
B`\x82' 

def getRWBitmap():
    return BitmapFromImage(getRWImage())

def getRWImage():
    stream = cStringIO.StringIO(getRWData())
    return ImageFromStream(stream)

index.append('RW')
catalog['RW'] = ImageClass()
catalog['RW'].getData = getRWData
catalog['RW'].getImage = getRWImage
catalog['RW'].getBitmap = getRWBitmap


#----------------------------------------------------------------------
def getSAData():
    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\x01sIDAT(\x91}\x91\xbdjTq\x14\xc4\xe7~d\xb3\x9b\xc0"q\x8b\x801FBj\xadU\
\x14l}\x8bT~4y\x04}\x86\xd4\x82\x9d\xd1\xbc@*\x9b\x10,T\x04\x85[\x08\x1b\xbb\
U\xd8\x15\xd6\xe4&{\xef93\xe7oa\xa2\xb1q\x8aa\x9a\x1f\x033\x19\x1e\xe0\xaf\
\x02 @\xc0\xce\xdd\x80\xe6BhP\x02x\xf6\xf0i\x02\x12\x82\xa2B\x11\xc1 EJ\x0cw\
\xbaB\n\xb9\xfc\xf5\xa3\xdd\x12@\x02F?G\x11\x91#\x07\xd2i{j\xb4\xb9\xb2\xe3\
\xb4\x995\t\xe9\xa4\xad\xeb\xe6xe\xe9*\x80\x12\x81\x94R\xcb\xe6\xd6\xf5;\xeb\
\x977\x8e\x9b\xa3w_\xdf\xdf\\\xbd\xd1\xc9;E\x96\x1f\x0c\x0f\xeen\xdc\xfb<\
\xfa\xf4\xe2\xeds\xa7\x9f\x01\x0cRr\xfa\xd1l\xda\x9d\xeb\xad\\\xba\xd2+z\x87\
\xe3\xc3\x96\xedt6\xfdQO\n\x14&\xba\x1c@\x0e\x83B\x94\x0f\x16\x07k\x83\xb5q=\
\xa9\xad\xae\xbeW\xdd\xce|\xf5\xad\xea\x16\x0b\xc3\xf1p\xaf\xda\x93H\xf1\xac\
A\xc1\x94\xb0\xfb\xf1U\x962\x06Mfn$\x1b\xb6y\x96ON&\xa4\xa7H\xe7\x80\x81\xa2\
\xcb\xcd\xdb\xcd\xdb\x9b\x0b\xe5bJ\xe9\xcfV\xfd\xf9\xbe\xcb\x9f\xec<n\xd52.\
\x02t\x06\xb7\xdfl3\x14\n\x939\xddd[\xf7\xb7\xf6\xbf\xec\xbb\xfc\xf7\xd0\x00\
J4\xf0\xe0r\x7f\x99\xe1NR\xeer\x8a\x1eNq\xe7\xc3KQ\xabK\xd7\x18\x8c\x08\x00\
\x19\xd6\xff9\x12-\xfe\xaf_0z7\x17\\\xc4@\x1d\x00\x00\x00\x00IEND\xaeB`\x82'\
 

def getSABitmap():
    return BitmapFromImage(getSAImage())

def getSAImage():
    stream = cStringIO.StringIO(getSAData())
    return ImageFromStream(stream)

index.append('SA')
catalog['SA'] = ImageClass()
catalog['SA'].getData = getSAData
catalog['SA'].getImage = getSAImage
catalog['SA'].getBitmap = getSABitmap


#----------------------------------------------------------------------
def getSBData():
    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\xcfIDAT(\x91\x85\x8dAH\x93a\x1c\xc6\x9f\xb5\xef\xfbH%\xdc\xc2\x82\t\
-\x0bV\x07CI\x0c\x84\xc5N\x16\x11Q\x87\xca\x08\x82X]\xbc\xe4\xa9\x08\xf1R\
\xb0h\x97\x0eQ\x04\x1dZ4\x08\xa6x\xf1\xd2h\xe1\xa0b\x0ea\x8e\xc0F\xd1\xa1I\
\x08}\xd1*\xb7\x9c\xce\xf7\xf9\xbf\xef\xd7au\xeewxN\xcf\xf3{|~\xffR"\xd1;9\
\xf9qj\xea@2\xe9j\xdd\x00\x0c\x00@\x00\xf3/;\x81\xd5\xfb\x17\xe2C\xa3\xb0R\
\xa9\xf0\xd8\xd8N\xdb\xc6\xc4\xc4\xee\x81\x81\xed\xa5R\x93\x84\xd6F\xc4\x131\
B\x1f\xc5:\x19]\x88\r\xbd\xf3:\xae&\x1e?\xf1\x01oS\xa9\x83\xc3\xc3]\xe9\xf4O\
\xd7U\xad\x96\xd1\xda#\r\xe9\x91\xb6\x1f\x9b7/??\xd4_\\Y\xb7o\x97\xec\xec\
\xf5\xac\x05X\xf5\xba\t\x06\xfd\xa2Mw\xf7\xb6fS\x94\xf2D|T\xce\xe9\xd8\x9bs\
\xc7\xe6\xd1Y\xcbVqw\xf1KxW\x18\x80\x15\x8d\x06\xc6\xc7{\xe2W\xaaOS}\xb3\xb3\
k\x99L\x8dt`Z7.M\x1f\x1e,|h\xc8\xb5\x17\xee\x96(z\xa4!\x00\xabP\xa8\xe5\xf3!\
*\xcc\xcc\xfc\x9a\x9bk\x90\x1d\'F\x16\xce\x1f\x7f\xd5t\xaa\xb9U\x7fr\xd1\xa5\
Q\xca(\nE\x04\x80\x05\xa8\\nM\xc4\xcbL\xff\x1e\x8c|>u\xb4\x18\xd9\xb7T\xdd\
\xd8\xbaW\xd8\xa8\xd4\xd6\x95\xa7\xa8\xa9D\xd1\x90\x9a\xed\x81!\xa1\x94\x13?\
\xf3\xb2\xbfo\xd9\x04\xca\xaf\xbf\xed\xb8Sti\xd8\x16\xb7\xdb"\xa2\xf5\xdf\
\x07kt\xa4\x12\x8c-G\xf6\x16\xbfC\x9e\xbdw\xf2+_\xe9Q\xe9\xb6\x9b\x14%\x86\
\xa2\xb5\x18\r\xc0\xbax\xe4V(p\xb6w\x7f\xe5S=\xf4\xa8\xfcC<{OO\x175E\x0b\x85\
bD\x8c\xe86F\x03\xf0\x15\x1f\xc0u\xf0\xb0\x8c\xf94\xb0\x89\xff\xf2\x07 \xdf+\
\xe0\x8e\xc56 \x00\x00\x00\x00IEND\xaeB`\x82' 

def getSBBitmap():
    return BitmapFromImage(getSBImage())

def getSBImage():
    stream = cStringIO.StringIO(getSBData())
    return ImageFromStream(stream)

index.append('SB')
catalog['SB'] = ImageClass()
catalog['SB'].getData = getSBData
catalog['SB'].getImage = getSBImage
catalog['SB'].getBitmap = getSBBitmap


#----------------------------------------------------------------------
def getSDData():
    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\x019IDAT(\x91\x95\x8f\xb1JBq\x14\x87\x7f\xde{\tS\xf4JK8\xb8\xf9\x00-\
\x8dAkm>A/P[CDS\x05A\r\xb5\xf6\x04-MBkPo\xe0\x138\xe8\x90\xdd"5E\xfc\x9f\xdf\
9\xa7A3\x83\x96>>\xbe\xe9\x07\x87\x83\xea\x1e\x1csuI\x01\xa6\xc0\x04\x18\x03\
\x9f\xc0\x00\xf8\x00\xde\x81\x1c\xaeq\xb3q\xb9\xff8\x88h0\x83\xaaS\xa1t\x12\
\xa4\x8b\xf8RG\xcdf\x02"\xab\xf4O6\'\xe7\xf7Y$\xea"Pu\x91\xb9A\\\x82\x87\xe0\
"\xb9Z\xcd\x80\x04\x84\x05\xefV\xb2\xc3Fz\xb5}\x16y\xce\xdd\xfc\x07[\x04ql\
\xedv\x04@]\x19\xd8-\xf5\x0e\x9e\x8e;+c/\x97\x97L\xbd\x9cz\x9az\x9az\xa9\xf4\
\x92\xcfG h**"\xd2I:\'\x0fG\xfa\xeb\xc2\x12\x80\x99E \xd4Hc\xb0\xb0\xae\xeb\
\xa7;\xa79\xc7\xdf{w3K@\xcc\xfe*\xbe\x15/v/\xa2i\xd4\x9f\xf4\xcd\xcc\xddg]\
\x10\xc7\xf1p8L`\xa0\xb3\xd0+dwY\xe3\xb6\x11B\x08!\x88\xc8\xbc"\x12\x02)\xa4\
\xd6\xeb\xf5V\xab\x95`\x84\xfc\xebj\xe1\xb9P]\xab\xb2\xac\xa4\xcc 9+I\xfd\
\x06\x00\xb0\x85\x7f\xf1\x05oFOu\xeb\xaaZ\x1c\x00\x00\x00\x00IEND\xaeB`\x82'\
 

def getSDBitmap():
    return BitmapFromImage(getSDImage())

def getSDImage():
    stream = cStringIO.StringIO(getSDData())
    return ImageFromStream(stream)

index.append('SD')
catalog['SD'] = ImageClass()
catalog['SD'].getData = getSDData
catalog['SD'].getImage = getSDImage
catalog['SD'].getBitmap = getSDBitmap


#----------------------------------------------------------------------
def getSEData():
    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\x01LIDAT(\x91M\x91?j\xd4q\x14\xc4\xe7\xbb\xfe4EDAQ\x08\x12\x04s\x00K++\
\x0b\xb1\x11\xef`\x11\x10\xb62n#(\x16\x966\xdaz\x854\x82\xa5E\x0e\xe0\x19\
\x02!\x9d\x8a\xa8\xb0l\xde\x9b?\x16fM\x86\xc70\xc5|^3\x03\x0f\xde`-\xbdz\r\
\x03\xc6\x85\xc5\x0b\x94Q\x85"Vu\x16\xba&\x00/\xe7\x8f\x00\xd8\x19;KX\x81\
\xe6{\x8f\xa9P\xa6\xdc\x12\xe5\xb6[\xfa4\xff0\x01\x00r\xfcs)\x07\'GI#:\xfc\
\xf6\xa7\xe5\xa6Z*\xaa\xe4nm_\xdf\x04j\x82mC\x0eO.\xfek\xc75\x8d\xd5\x92\xb3\
\x92\x9b*\xaa\xa8\xb6Z\x06j\xe8\x00\xe3\xce\x02u\x94\x10a\xdcq\'\x1dw\\q\x9d\
\x86\xf4\xd8\xb8\xfd\xfb\xcb\xc1\x04\x02Q\xd2\xf1\x1aH\x9dbg\xed\x8a\x1b\xa6\
\x89\tF\xc2\x98I\xc1\xe7\x81s\x9e\x8a{\xb8M\x0c\xdc}\xfel\xf1\xe4\xf0\xfb/\
\xca\x9f\x1f\xbeK:\xae{\xfb{M\x96\xdc\xabY\xd1-\x93\xda\xb9y\xe5\xeb\xdb\xf7\
\x13V\xa4\xd5R\xd3\xebgUdQ-\x17\xaa!\x0esf\xce6\x80\xe3\tUMo]\xddl\n\x97n!\r\
\xf7\xf6\xb5\xcb\x94\x9b\xa6EG\xb2d\xd9\x80\x07\xb6\x9e\xfe\x1f\xf2\xc7\xc7}\
\x10&n\xec\xde\x07\x08\xd4\xfa\x0c\x100\x80\xbf\xdc\xb9y\x88\x95UXZ\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getSEBitmap():
    return BitmapFromImage(getSEImage())

def getSEImage():
    stream = cStringIO.StringIO(getSEData())
    return ImageFromStream(stream)

index.append('SE')
catalog['SE'] = ImageClass()
catalog['SE'].getData = getSEData
catalog['SE'].getImage = getSEImage
catalog['SE'].getBitmap = getSEBitmap


#----------------------------------------------------------------------
def getSGData():
    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\'IDAT(\x91\x8d\x92=JCQ\x10\x85\xcf\xbd\xefB4$\x9d\x8d\xf8\x93\xd2"\
\xae +p=\xda\xbb\x96\xac!U\x8a`\xd2)i\x14L\x1f\x02\x82\x88(\xa4\x9183\xef\
\x1c\x8b\xa7\x82\x8a\xe2\xc7t\xf3\xcdi\xe6\xa4\x07\x80@\xd9\xde\x86Y\xd45\
\x01\x02\x00\xf8c\x02\x00P\x08\xec\xcc\xe7\xd5\xf1\xb1\xcdf\xbc\xbd\xcd\xfd>\
\xd7\xeb\xb8\xbaR\x84"\xe0\xce\x08\xb9+B\xeew\xa3Q\x01P\xf5\xfb~y\x19\x93I99\
\xd9\x0c\x87\xf9\xf00\xed\xed\xfb\xf4B\xee2\x97\x1b\xcd\xe4^\x1d\x1c\x04P\
\x00\xa8\xae\xab^os\x7f\xcf\xf1x\xeb\xecL\x11/\xe7\xe72\xa7\x9b\xdcd.3\xb9\
\xd3\x9d@u\n\xb4\x06\x83|t\x04)\xaeo|6{\x1d\x8f\x9bl\xba5\xaa\xcc\xe8\x9e\
\xbb\xdd\xc7\xd5\xaa\x14\xa0^,l:\x15\x12:\x1dD+\xb7\xdb\x8c\x80{vo\x82\x11\
\x91<\xd2\xeen\x01\x92\xaf\xd7\xb9\xd3\x91$\x08\x82~\'\xe7\xfc\xb4\\\x16\x02\
I\x92\x04\xfce7\xdb\x00\n\xc9\n\xf8\xcf\x01\x00D\x14\x92\x9f6>H)\xe1\x0b\tP\
\xf3\xcd\x02r\xf3\xfc\xccw\x82\xc1o\x80\x0c\x12d\xd3\x807\xec`N\x0c\xb9\xb5\
\x8e\x1e\x00\x00\x00\x00IEND\xaeB`\x82' 

def getSGBitmap():
    return BitmapFromImage(getSGImage())

def getSGImage():
    stream = cStringIO.StringIO(getSGData())
    return ImageFromStream(stream)

index.append('SG')
catalog['SG'] = ImageClass()
catalog['SG'].getData = getSGData
catalog['SG'].getImage = getSGImage
catalog['SG'].getBitmap = getSGBitmap


#----------------------------------------------------------------------
def getSIData():
    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\x01FIDAT(\x91m\x8c\xb1jTa\x10\x85\xcf\x7f\xef\x0f\xca\x16\x81\xa0`\x16;\
\xb1\xd4J-\xad|\x05\x0b\x11\x1fC\xb0S,\x02v*\n"\xd8\xa8Ez;[}\x03\x1b\x1b\xb1\
\x89EX\x85\x84\xcd\xbd\xba\xfc\xe7\xcc\x19\x8b\xbb\x86U\xfc\x18\xbe93\x03S\
\xc6q\xc4\x06\xb6\'o\x86\x13dW\x00\xb3\xd9,\x13\xabU\xa0\xe4\xect\x0f\x00\
\xc8\xcc\\\xb7\r\x86a\xa8\xd3\xe3\xc7\xcf\xf7\x0f\x16\x87\xbdc\xf7\xe1et]\
\xfe\x8fR\x8a\xed\xd2o\x7f|\xf2\xe8\xc2\xf1\xb1n\xdf<\xf3\xea\xedb\x18\xc2\t\
\xc9\xa2\xa9\x94L\x99\xb4\xe4\x9ds\xa7^>\xfdP\xe3p\xd8\xff\xb6\xba\x7f\xedKl\
]\xbfw\xe9\xf3\xad\xd7;DO\xb9\xd1ln4\xe9\xd6L\xc6\xd1\x92\xc0\x8f\nX\x897{\
\x8b\xb3\xef\xf6\xc4`\x9eo\x99TR\xd9\x94m\n\x91\x14\x14\x00\\\x81\x1a\xee\
\xde\xf7W\xdb\x91E3\x93tS\xd7\x02\x0c\xb4(k\x1bt\x07\xd4\xba\x8b;7\xc6\x07\
\xcb\xe5\x81\xa5h2\xff\x98\x8c\xa6\x90\xdcd)\x18[\xdb\xf3gxQ\xef\xe2{\xff\
\xeb\x93\x7f~\x05\x99d\xb6\x96\xad\xad\xc3\xc9F\x84\xa2\xac.^\x01\xaa\x81\
\x8e\xc2|\x9e$\x14\x10A\x16\x12\x12&K\x88\x98\xca@\x19\x01o\x14\xfe\x1e\xff9\
\x01\xf8\r^\x88\\1\x86\x01\xff\xc6\x00\x00\x00\x00IEND\xaeB`\x82' 

def getSIBitmap():
    return BitmapFromImage(getSIImage())

def getSIImage():
    stream = cStringIO.StringIO(getSIData())
    return ImageFromStream(stream)

index.append('SI')
catalog['SI'] = ImageClass()
catalog['SI'].getData = getSIData
catalog['SI'].getImage = getSIImage
catalog['SI'].getBitmap = getSIBitmap


#----------------------------------------------------------------------
def getSKData():
    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\x80IDAT(\x91e\x8e\xbfK\x95q\x14\xc6\x9f\xef{_oz\x8d,D\\\x1c\xa2\xff\
"!"Qj\xe8\x0f\xa8\xc1\xa0p\xca\x1c\x1a\xeaB\xd1\xd4\xd6\xd4 \xd4TC\xa8\xa3D6\
4\x88\x05M\xfd\xd8\xcc(\xc2Eo\xf4\xdb{My\xaf\xf7\x9c\xf3<\r\xafH\xd6\x87\xc3\
\xe1yx8\x0f\'\xc5v\x01\x10{\x90\x04@\x90di\xb8\x87\x93\xc8\x01d\xb5\x1a\x00I\
\xe5I&\x00JR\x05\xd0~\xb6\xbe\xfd\xc8\xcb\xfa\xe2\xe1#lnI\x94\x07\xc0\xee\
\xabS\xfa\x8f\x94\x92\xbb\xe7#\x13\xebS\x17\x06N\xaf|\xec\xddh\xe8\xe6-\xcc\
\xcd\xc6\xbb\xf7\xd3\x0f\x1amV\xc2\x19A\x0f\xb9\xd3\x83\xfd\x87\xf3\xfa\x95\
\x95\xfc\xe5\xab\xe6\xd8H\xffX\xbb\xad\xcb\x93\xe8;\xa4\xf1\xf1\xb8~\xe3\xe7\
z\xebC\xb3\x1b\xee\xe6\xb4\x90\x1b;\xce\xa1\xc1*\xe2K\x16\x0eQ\x0c\xea\xfe\
\xb4Z\x9b\x9a\x9b\xc92\xfd\xeedNY\xc0\x03n2\x87\x07\x82\x00\x90\x03U\x89k\
\xe7&\x17\x16>7\xee\x15\xd89s\xed\xfc\x89\xaf\xcf{,\x18\x941\x992\x17\x9diG\
\x15\xa0\x9a\x96\x80c\xf5;]}\xb5\xe2\xe4\xe8\xed\xc7]\xf5\xb3^[|\xdaz\xf1\
\x9a\xe64\xa3\xd9\xeeO\xe6\x07\x8e\x0e--\xce\xe4\xc3@e\xe3\x13\xdf\xae\xe2\
\xd7\xea\xdd\xe3\xa7\xd2\xb37\xd5\'\xf3\x03f\xeatd\xa6R\xb8\xc1#\x1dl\x1e\
\x01R\x01\xe4\x17/\xc9Mf\xf0\xd8\x15frW\xb9\xdd\x15\x81\x08D|_^N\xdb\x00\xff\
\x1a\xec\xb7\xffD\x00\xfe\x00K\xdfG\xb9H4\x87\xd3\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getSKBitmap():
    return BitmapFromImage(getSKImage())

def getSKImage():
    stream = cStringIO.StringIO(getSKData())
    return ImageFromStream(stream)

index.append('SK')
catalog['SK'] = ImageClass()
catalog['SK'].getData = getSKData
catalog['SK'].getImage = getSKImage
catalog['SK'].getBitmap = getSKBitmap


#----------------------------------------------------------------------
def getSNData():
    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+IDAT(\x91U\x911j\x96a\x10\x84\x9f7\xf9AA\x04\x1b1\x11b\x91.\x95\x9d\
vv\x16v\x1e\xc0B\xb0\xf4\x08\xa9r\x03o"\xa4\xf1"v\x82\x85h%\xd8\x18\x15wfw,\
\xbe_\x83\xc3\xb4\xcf\xec\xb0\xb3\xb8\xe0Z\x83^rp\x00\xc3l6s\xc6p\xed\x1dp\
\xfe\xec\x1c\x98\xccd\xd6\x83\x86\x06\xaf_>\x1c\x1f\xdcT^8R\xecHW\x97\x97;\
\x00\xf2\xf9\xc7\x97N\xf74\x11\xab\x13\xe5\x86\x12e\x94\x0f\x95\xaaH\xeb\xe4\
d`\xc70\x93\x9ev\xda\xa3\xd0\xa4\x12w\xb4RI\xa5\xb4\x01H{\xa0i\xc7n{\x9c\xe8\
Jz\xfbQ\xbf[\xcfO\xeb\xce\xe1\x7f\x00\x1b\xe0i\xb5<\xf6\x98\xe8\xfd\xb7z\xf7\
I\xdf\xa5\xfb\xb7\xeb\xe9=\xa5\xf6\x95\xb0\x07v\x98\x1e{\\Sn\'zt\xb7\x1e\x1f\
\xe9g\xd5\x93#e\xae/\xac}%\xa3\xa8\xba<VW\x10\xa9\xd7gJ\xd4\xa9\x8c\xfe\xc5\
\xc7\xf6\x06\xb8\xad\x96Fj%E*QR+J\x94\xaaX\xb8\xe9\x06v\x14\x1a\x1f\xdf:V\
\xcb\xdb[\xd1Z\x02\x83X\xe6\xd4to\x1eX\xbc\x82\x02CA\xf1\xf5\r\xf0w\xe6a\x8a\
y\xb8\xdfx\xd3\x1f\xfe,[\x91A\xea\xa2\xe8\x00\x00\x00\x00IEND\xaeB`\x82' 

def getSNBitmap():
    return BitmapFromImage(getSNImage())

def getSNImage():
    stream = cStringIO.StringIO(getSNData())
    return ImageFromStream(stream)

index.append('SN')
catalog['SN'] = ImageClass()
catalog['SN'].getData = getSNData
catalog['SN'].getImage = getSNImage
catalog['SN'].getBitmap = getSNBitmap


#----------------------------------------------------------------------
def getSVData():
    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<IDAT(\x91U\x91\xbfj\x94Q\x10\xc5\xcfu?\xf7\xd3\xf4\x11V\x88\x08\x89\
\xa4H!\x01S\xfa^\xa2\x90\x07H\x936>\x89E\x8a\x80\x10B\x12Ro!6\x16!\xa8\x08.\
\x86\xc8\xbd3\xbfcq\xb3K\x1c\x86\xe10\xcc\xbfs\xa6\xe8\xf5\\U\xf7\x06\xaa(P\
\x95*\xaa\xa1\x8a\x1a\x12R\xf48\xa8\xea\xf0\xc3\xb3^\x0c\x02"\x958!S\x11\x8e\
t\x04\x1d\x1c\xed\xcf\x07A\xa2\x9b\x9f\x01\xcet\xa4#\x9d\xe9\x16\x8e\xa0\x85\
[\xb8\x05\xad1[\x7f,\xd5rry\xbb\xb91\xad\x15[\xb6\xe9\x0eF\xb6\xc0`\x0cx\x9c\
>\xfa|\xfe\xbddf)E\x92mY\x96m\xff\xfa\xb2\x7f\xcb\xf8|\xeb\x9d\x1fX)e\xb1X\
\x0c\x9dmOup5\xbf;\xff\xfa#ho\xee\xfe\xec\xed\xac\xad\x1aT\n0\xac\xaaW\xf3w\
\xb7\xa7\x8b\xf66\xc9\xbd\x9d\xa7\xffm\xb0\x81r|\xf6\xfb\xd5\x8b\xf1o\x05l\
\xbb\x1f\x1dN\x90,pg\x80\xfdd\x9c\x1c\x9f^\x17\x8d\x97\xef\x0f6\xbe\xdd\xd4\
\xa5&\xd4p\xa6[\xa3\xb5\xec*E\x12\xe9\x97\xb3\xe9\xa7\x8f\x17\x83\xc0\xd6l}h\
\xe1\x0c"\x1d\xe1\x96D\x121\xc9\xbc\xd7\x1a\x9cH\xa2hr\xaa\xd4\xea\x91\xcb\
\x18K\xcc\x03\x80\xa4\x7f\xa4XlM\xcd\x85\xad\x8d\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getSVBitmap():
    return BitmapFromImage(getSVImage())

def getSVImage():
    stream = cStringIO.StringIO(getSVData())
    return ImageFromStream(stream)

index.append('SV')
catalog['SV'] = ImageClass()
catalog['SV'].getData = getSVData
catalog['SV'].getImage = getSVImage
catalog['SV'].getBitmap = getSVBitmap


#----------------------------------------------------------------------
def getSYData():
    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\x0cIDAT(\x91\x9dN=K\x03A\x14\x9c\r\xd7\x86\xd4)R\xa8\x87\xbfGE\x10\
\xd1:\x7f"?$\xa5`\xa5\x87\x10H\x19A\x7f\xc3\x15V9N"\x11m"\xdc\x11\x0c\xd9y\
\xfb\x9e\xc5&\xa7B\xb0px\x0c\xf3>fw\x9c\xe1\x1b\xfa[\xef,g\x00\x06\x03\x00\
\xa6\nU\x84`\x12\x10\xc4D b\xa4\xfd\xe0\xe5x\x9c\x00\x00\xcc\xe6\xaf\x08\x01\
!\x18\x19yS\x9eFo\xde\x1b\xe9z=\x05\x92\xba\xaa\xda\xed66>\x8b\xbc\x13p\xeec\
6k5\xa1\xcdl\xa5\xeb\xac\xbc[\x19\xe3\x85\xb7p5\xbd\xaee\xd9xT\xb5\xa5\xaa\
\xcd\xab\xa3\xe7\xd1\xe3\xfc!\x9b\xde\xc46+n\xef_&\xc3\xa7\xe1\xf6\x0b\x88H\
\xa2M\x06\xd8\xc9\xdeQ\xbd\xaeN\x0f\x8e\xe3\xe0|\xff\xec\xfd\xf3\xed\xf2\xf0\
"\xb6\xce\x0c\x80[,\x16\x9dN\xe7\xef\xf4q\xeb\x9c+\x8a\xc2\x01\xe8\xf7\xfbeY\
\x92$\xe9\xbd\xf7\xdeGA2*\x11\x8a\x844M\xf3<O\x00\x90\xd2\xedvI\x8a\x04\x91h\
\xa4\x88D\x16\x91\xb0\x05\xfe\x81/=\x07M\x1d\x06\xbc\xc3+\x00\x00\x00\x00IEN\
D\xaeB`\x82' 

def getSYBitmap():
    return BitmapFromImage(getSYImage())

def getSYImage():
    stream = cStringIO.StringIO(getSYData())
    return ImageFromStream(stream)

index.append('SY')
catalog['SY'] = ImageClass()
catalog['SY'].getData = getSYData
catalog['SY'].getImage = getSYImage
catalog['SY'].getBitmap = getSYBitmap


#----------------------------------------------------------------------
def getSZData():
    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\xc6IDAT(\x91%\xd1MK\x94a\x14\x06\xe0\xfb}\xe7\x99\xc9\x9a\xa2,BJ\
\x9aM\r\xd2\xa2\xa0\xc0e\x10\xa66\x05\xb6k\x13\xb4\xae\x08\xda\xe8\xa2\xc2A\
\x90\nj\xd3w\xab\n\xd4EQDQ\x11D\xd2\xca]$\xf4e\x81A\x81\xa3\x8b\x90\xf0k\xc6\
w\xces\xce}Zt\xfd\x85+9~\xfdC#S\x00\x00H*!\xa4*U(\xaa\xa2\xccTET\x94\x99hKH\
\x03\xc3\xd2\xe9J\x19\x00\x1ct\xa7\xbb\xbb\x9b\xd1\xd4\x08\xd0a\xa4\xd1\x8d4\
\xb2\x7ft"\x8c\x16z\x0b\xf9\x9b\xbe\xfa\xc7I\xb89\xcd\xa9NsW0\xba\xa93\xbaER\
\xd3\xb5m=\xe1n\xb8u\xcaz.\xcc.\xcf\xcc\xb8Y\xf0\xf8\xbbio\x1cQel\xe4\xe1\
\xca\xb7/\x9f\xef\xdcX\xfc5kQ\xb2fl-\x95\xee\x8f#%\x10\xcd\x90h\xb9k\xdd\xe6\
\x83\xc5\xd7\xa4&i\xb3)S\xd3?[:v\xef\x1c\x1c\xea8\xb1\xbds\xe4\xc1\x0f\x91\
\x18\xe3\x02\x90*\x90\xc0J\x95m\xab\x9b\xb6\x0e\xbf\x9a\xef\xeb;z\xecHw\x8c\
\xb1^\xaf\x0f\x9c\xaf\xbe\x18\x7f_\xec<;\xfd\xf2\xe2\xe13\xfbC\x91\x02\x04\
\x05\x80t";$\xb9\xd6n\x99|\xfc\xe8\x89\x9aeY\x16B\xa8\x0e\r\xd6&?}\x1c\xa8~?\
p\xb2\xb1\xa1\xbcw\xe1\xb2\x02!\x05Lm\xcb\xf3{\xeaX#\xcdJ\x8c\xefD\x16b\xcc\
\x1b\x93\xa9\xafs\xd7\xae\xfc\xad\xcd\xb5\x8d]\xd24\x97\xb4\xb7\x03H\x16\xaf\
\xa2\xd05\xcc\xe5\x9a[t\x8f0#\xa3Y\x04\xcdM@!\xd5M\xdd\x186\xee\xa8\xdd~\x16\
z\x1bO\xcf\xc9\x1e\xe6]s$\xa99w:I\x91\xc8\x1c\xe8nt\xa3\xd3\xe9\xe2\xd5lW\
\xb2\xaf\xff\xed\xfcR\xf6?2\x13\x15\xa1\xabB\x14\xa2\xa0B\x08!TAB\x89\xf5\
\xe1\x1f$\xeeaN\xbc\x0e\xd5\xeb\x00\x00\x00\x00IEND\xaeB`\x82' 

def getSZBitmap():
    return BitmapFromImage(getSZImage())

def getSZImage():
    stream = cStringIO.StringIO(getSZData())
    return ImageFromStream(stream)

index.append('SZ')
catalog['SZ'] = ImageClass()
catalog['SZ'].getData = getSZData
catalog['SZ'].getImage = getSZImage
catalog['SZ'].getBitmap = getSZBitmap


#----------------------------------------------------------------------
def getTHData():
    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\x0eIDAT(\x91}Q\xb1JCQ\x14\xcb\xb5\x0f\x8aT\x1d\xaa\x8bS\x17urq\xd0\
\xdd\xc1\x8f\x11\x1c\xab?\xe0\xcft\x15\xbaIq/~E\xf7:\xd4\n\xf6\x9e$\xc7\xe1A\
k\xa1\x1aB\x08g\x08\xe1\xa4$6\xf0\xb6\xdf\xc9\x92\x00\x9e\x9f\x01\xa4\x05\'\
\xc8t\x82\x91\x12\xc8$3"#\x92Lr9\x1a\x95\xcc\x04\xd0\xea\xda\xe4.\x94R\x16\
\x8bE\xb9\xbd{y\xb8\xbf\xfc\xf8X\xc9i\xa5l\xd1T\x8a\xa2,Z2\xc3\xb4\x8f\xfb\
\xfbO\x8f\xe3\xe6\xed\xf5\xfd\xfa\xead6\xfb$\xcdp\xd0\x11\x8aP\xad\x8eP\xadZ\
\xeb`p\x04\x8c\x1b\xc0mO2\x19\x19\xccZ\xdb\xda\xae\xd552\xaa\xdb\x0b\t\xc0\r\
\xf0-\x91\x8c\x1afh\x1d\xff;\xbbVE8\xa2\x02\xcb\xa6wxqv\xde?8\xec\x92I*h\xd2\
\x0c\x91\x0e\x9a\x14i\xd2\x92OO{\xd3\xe9MY\xadV\x9dN\xc7\xf6_\xcfi\x01\xa0\
\x942\x9f\xcf\x1bw\xbb{\xc3!\xda\x8e\x12\x82\x10K\x04\xc8\rmH\x90<\x99\x94\
\xaf\xed!\xff\xd9\xb8\xc5\x0f_\xffe\x8c$1\t^\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTHBitmap():
    return BitmapFromImage(getTHImage())

def getTHImage():
    stream = cStringIO.StringIO(getTHData())
    return ImageFromStream(stream)

index.append('TH')
catalog['TH'] = ImageClass()
catalog['TH'].getData = getTHData
catalog['TH'].getImage = getTHImage
catalog['TH'].getBitmap = getTHBitmap


#----------------------------------------------------------------------
def getTJData():
    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;IDAT(\x91\x8d\x8f\xbdN[Q\x10\x84\xe7\\\x9b K\x96\x0c\x15\xe2\xc7I\n\
\\\xf1\x04\xf4<\x0b\x05\x05\x1d\x12\x92\x83\x92\x86"Ux\x16^ E\x9a\xb4\xf4\
\x91-G\xb8\xa1\xc2\x85\x11:3\xbbCq\xe1\x862\x9fV\xabYi4\xda)?\xf1\x8f\x04\
\x12\x00 @og\xa7[\xd1\x070\x99N\x018\xd3\x99\x88\xb0"C\x96,\x99L\xc9\xa4\xa5\
$\x7f\xdd\xde\xf6\x01\x00\xae\xf7KG "\xc9\x8c0\x99\xa4\xc9\xacLV\xd7\x9a\xe4\
\x87\xf1X@Y\xaf\xd7\x83\xc1\xa0}\xc96\x80\xfa\xe7[3<2z\xb1\xfa\xdd\xfb<u\x19\
\xd8\xb6]JY.\x97MW\xc06\x0c.n\x9a\xadc\xc7\x93\xf5\xd8;8\x8b\xbf7~\x87\xa4&3\
[\xb7m.~\xf4\xc6\xe7e\xfb\xc4\x96S\xde\xd8+\x1f/c\xf6\xf5\xd5\x0edfY\xadV\
\xc3\xe1\xd0m\xbea;\x16\xdf\xfd4s\xca\x9b\xfb\xe5\xd3U\x17\xdf4\xcd|>\xefw\
\xf1\x9d(\xe3\x0b\xd8\xedtt\r\x0b&8\xfdr:{\x98Qd\xb0\xaaVU\x8a5*\xc5*2\xaa\
\x82\x8a8\xdc9\xbc\xbb\xbe\xeb\xe3\x19\x0c\xed\x8ev\x19T\x84\x82\x0cRT\xaa\
\xdd\nEFDD\x06\x00`\x07\x18\x01\x9b\xf8O^\x00!\x0e:$\x8c\xf3]\xab\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getTJBitmap():
    return BitmapFromImage(getTJImage())

def getTJImage():
    stream = cStringIO.StringIO(getTJData())
    return ImageFromStream(stream)

index.append('TJ')
catalog['TJ'] = ImageClass()
catalog['TJ'].getData = getTJData
catalog['TJ'].getImage = getTJImage
catalog['TJ'].getBitmap = getTJBitmap


#----------------------------------------------------------------------
def getTMData():
    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\x8fIDAT(\x91\x85\x8e?kSq\x18\x85O.\xf7\xde\xdc\xa4\xf6\xcf$\xad8h\
\x17\x07q(H\xc5\xc9Qp\x94\x8e."\xfa\x05\x82\x14\xa4\xbb\xa3:\x16\xfa\r\x9c\
\x04A\xd0\xc5\xc1\xa9\xb4\x0eM\x0b\x1am\xd2`4X\xaa&&5\xb9\xef9\xef\xef:$\xb8\
\xfa\x0cg;<O\t\xd7\x01\xe0\xcd\xcf\xa5\xde\xc7\xee\x10\xb8\xbb\x02\x083\xabW\
N\xdf\xd6a\xc0\x18\xd3\xcd1!\x06\xb0Q{\xb2\xdc\xcd\x8bPN\x17\xaa\x0f\xd3\xde\
L\xb9\xf2k\xd8\xbb]\xdb\xdam\x1d\xecw\x1ar1\x90r:_\xd46#\x00(\xf0\xfb\xe8k\
\x94\xb7\x8fw\xde/T\xce\xec\xb5?\xccWg\x1f\xbf\xdc\\[\xbd\x99\xcb>}?jt\xdb\
\x8doM\xba\x00D\x08\x08EH\xd2\xa2\xdf\x1d\xa5I\xd8i\x1d\xdc\xbb\xb1\xb6}\xb8\
\xb7~\xebAT\x8a*I\xd9D\xa3\x99\x93"\x80\x18\x01\n>\x1e\xf0t\x94g\xa5B\x8e\
\xd7\xf5wO\xefl\xd0\xfd\xf9\xf6\xab\xd6I\xc7H\x13)R\x02\x10\xc3\x10\x82\'\
\x89\xff\x19\x86\xd9j0\xa9\xdei\xdc\xdfztiq\xb9y\xf2\xe5\xb8\xff\x83\xa2\x89\
&M\x92b\x08\n>\x1aX3\xe3\\\x9f\x14\xcc\xcd\xa4\xdd\xf6>IsR2\x91\x92\x9cS\x83\
\xe4i\xe2\x991\xab\x16&\x9b\x04\x98\x8b\x9a\x1e(\xd2\xe5\xc1\x01D\x18\x83As+\
\xd7\xae\xa6\xc8.\\\xb6i\x00Mf2\xa3&=r\xc9\xfd\x9fA\x83\xc3F|\xf6\xa2\xf5\
\xba\xe7\x96\x16%\xd1I\xa7\\\xf2 \x97\x07ww\x05\x01(a\x1e\x18\xe3Y\x8e\xf3\
\xc0g`\x1d\xff\xe1/\x0b\xd0A&\xe7\xb8\xaev\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTMBitmap():
    return BitmapFromImage(getTMImage())

def getTMImage():
    stream = cStringIO.StringIO(getTMData())
    return ImageFromStream(stream)

index.append('TM')
catalog['TM'] = ImageClass()
catalog['TM'].getData = getTMData
catalog['TM'].getImage = getTMImage
catalog['TM'].getBitmap = getTMBitmap


#----------------------------------------------------------------------
def getTNData():
    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\x017IDAT(\x91}\x91\xb1JCa\x0c\x85\xcf\xad]\x05A(\x14[\x07\xa7\x8evq\xf2\
\x01\xd4\xa1[\xa7\x82\xb3\xa3nB\xdf\xa1\xabN\xbe\x82\xe2\xe0$\xb6X\xe1.\xbat\
\xed\xaa\xbbP]n\x92\xffs\xf8\x8bZ\x10C\x08\xe1\x90\x8f\x84\x9c\x02\xfdDZ\xed\
\xff\xcc\x02I\xc3\xa1$RRJ\x8a\xc0C\xe1\xb8\xcb\x1d3~\xd5\x8f\xdb\xdb\xba$\t^\
\xdf\x14\xa1\x08NN\xb4\xbd\xcd\xc6\x06\xc0tJY2\x1eSU\x98\x15\xedv\x92\xea\
\x92H,\xa7\x8f\x8f\xb5Xpy\xc9|N\xbbM\xafGk\x8b\xee.\xd3'\xccd\x96\xa4Z\x92\
\x14\x91\xb7+%\x1e\x1f\xe9t\xb8\xb8`s\x93\xb2\xe4\xe0\x10s\xaa*/\x91T\x93$\
\x0f\xcc0#\x82\xf9\x9c\xa3#F#&\x13\xba]\xd6\xd71[\x02\xee)\x03\x84\xe3\x8eU\
\xa4D\xab\xc5\xcd5\xa7\xa7\x0c\x06\x94%\xef\xef\xdf\xc0\xcfIY\x929\xee\xec\
\xef\xf3\xfcB\xbf\xcfx\xcc\xde\x1e\xb3Y\xfe\x8f\xdcqw\xa9\x9e\xa4\xb5,\x991\
\x1aq~\xce\xd9\x19\x8d\x06\xc0\xdd\x1d\xf7\xf7<<\xe0&\x0fE(\x035s5\x9b\x98\
\xc9CWW2+\xcc\xe4\xae\\wv\xf2\x0f\x15\x91\xa4\xe2s\xd5\xc8\x7f<\xce\xf1\x05g\
\x93;~\x84\xff\xbb8\x00\x00\x00\x00IEND\xaeB`\x82" 

def getTNBitmap():
    return BitmapFromImage(getTNImage())

def getTNImage():
    stream = cStringIO.StringIO(getTNData())
    return ImageFromStream(stream)

index.append('TN')
catalog['TN'] = ImageClass()
catalog['TN'].getData = getTNData
catalog['TN'].getImage = getTNImage
catalog['TN'].getBitmap = getTNBitmap


#----------------------------------------------------------------------
def getTOData():
    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\x00\xf6IDAT(\x91uRAn\x021\x10s\x96=V\x8b8r\xe0\xc8\x8d\xe7\xf0\r\xa4\
\xb6|\x81\xf6\x17\xf4\x01\x1cy\x0f\x12\xed\x13V\xa2\x87\x8e\x9d\xb8\x87,hWj#\
\xcbR\x14\xdbq4I}\xdfc\xb4J\x01P\xba\xc5\xa2\x00\x7f\xa2\x05\xd0u\x1d.\x17\
\x9fN\xd8n\xb1^\xdb\xc0n\x97\xa4\x99\xd4\x90\x96|\xe7\xdb\xf9\xdc\xd6`\x1f\
\x0e\xc8\x19o\xef\xfe8"%_\xaf&M:h\x86#L\xa6\xd5\xaa\x00\r\x00\xdb\xd8\xef\
\xd1\xb6~y\xae\xdbA\x1aa\xfe8b\x009T\x02\x80\xcd\xc6\xc7#\x0c\xc3\xb6\x1d1\
\xce\xae\x0c\x12@\xfb4\x9f\xe3u\xef\xafOK\xa0\xac\xe1\xf8\xa1{\xc4C\x1anp\
\x96%3@\x995\x98\xe3\xec\xe1\r\xb5R\x01\x12\xe9\x08H\x13\xd1T\r\xc9\x92\xaaa\
&\xd5\x8a\xe3\x02\x13\x9b\x08e\xe4\x8cjh(,\x97&\xa1\x0c\x11d"!\xa1\xb2\x84\
\x9c+\n\x90\xbe\xa7\x83\xc4?\x03.\xf7\xaf\xf0\x0b\xfe\x1dN\xdfm\x87\xb5\x86\
\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTOBitmap():
    return BitmapFromImage(getTOImage())

def getTOImage():
    stream = cStringIO.StringIO(getTOData())
    return ImageFromStream(stream)

index.append('TO')
catalog['TO'] = ImageClass()
catalog['TO'].getData = getTOData
catalog['TO'].getImage = getTOImage
catalog['TO'].getBitmap = getTOBitmap


#----------------------------------------------------------------------
def getTRData():
    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\x019IDAT(\x91}\x91=JCQ\x10\x85\xcf\x8b\xb1S\x03\xb1\xb2\xb0\x10\xc1\xc6\
\xda, h:\x17 v.\xc1\x05X\x077`\xafE,,$U\xaa\x94\x81`\xe7\x12bV\xa0y\xa0wf\
\xeegq\x1fh@<\x0c\xc3\x14\xf31?\xa7B?\xca\xeb\xf5\x9fQ!\xe9\xe6F\x11\xe4\xac\
\x9c\x15\x81\x87\xc2q\x97;f\xfc\xca\xab\xf1\xb8-IU\xc5r\xa9\x08E0\x18(g&\x13\
\xde\xdf1#\x19\x96H\t\xb3j\x7f?KmI\xe4\xdct_^\xea\xe4\x043\x0e\x0f\x19\x0eI\
\tK$+\x80\xcc\xb2\xd4\xca\x92"\xe4\xce\xc1\x81\xfa}\xee\xee\xb8\xba\xe2\xf9\
\x99\xbaf4bk\x1b3R3DRK\x92>\xbf0\xe3\xf4\x8c\x08f3R\xe2\xe5\x85\xc7G\xba]\
\x9e\x9e\xe8\xf5\x1a\xc0=\x17\x80p\xdcY\xbe!q|\x8c%\x8e\x8ex}e8d\xb1`:-@Y\
\xa9\x9d\xa5\xca\x8c\x94\xf4\xf0\xc0\xce\x0e\xd7\xd7\xd45\xc0\xc5\x05\xab\
\x15\xf7\xf7\xcd2\xee\xb8{\x016\xdc\xcbM\xdc\xder~\xce\xe6&\xa3\x11\x1f\x1f\
\x985\x07\xb8\xc9C\x11*@\x0b\xb4\xb7\x87\x99<4\x9f\xcb\xac\xda\xddU\xa7#3\
\xb9\xcb\xbd\xfcP\x11Y\xaa\xeau#\xff\xf1\xb8\xe8\x1b]@>O\x98\xdeiy\x00\x00\
\x00\x00IEND\xaeB`\x82' 

def getTRBitmap():
    return BitmapFromImage(getTRImage())

def getTRImage():
    stream = cStringIO.StringIO(getTRData())
    return ImageFromStream(stream)

index.append('TR')
catalog['TR'] = ImageClass()
catalog['TR'].getData = getTRData
catalog['TR'].getImage = getTRImage
catalog['TR'].getBitmap = getTRBitmap


#----------------------------------------------------------------------
def getTTData():
    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\xd1IDAT(\x91M\x8b\xbfK\x1ba\x1c\x87?\x97\xc3%\x9ed\x0c\x19\xb2\x04\
\\\xdb\x8a`K\xa0\r\xa5\x05\x83\xb4\x1d:\x0878(\x15\x11\x94\xd0.\x0ei\xab\xff\
\x81\xffBWW7\x8988i\xb8&\xf68{$\xef%w\xc9K"$\xbd\xab\x8d\xe6\x87\xf7&\xef\
\xb7SK><<\xf0\x0c\x1fL\xba\xddD"\x01\x00@<\x1e\x9f\xb4Z\x13]\x9f\x00\x02x\
\x00\x86@\x1f\xb8\x03\xfe\x00\xbf\x01\x1fPh~\x9e\xae\xae\xbe\x1d\x1d1\xc6\
\xa4\x94\xa9T\xea\x83\xae\xe3\xec\x8cNN0\x1e\x93\x104\xe5\xfb\xe3c\xf5 \x08\
\x94L\xe6I6\xfb\xdd4\xab\xd5*c\xccv\x9c\x17\xab\xabt{K\xe7\xe7\xd4\xfdE\xdd.\
u:\xd4\xe9(\x9a6r\x1c\xf5\x00\xa0d\x12\xbd\xbb\xb4\xae\xdb\xb5Z\xbb\xdd\xe6\
\x9c[\x8c\xbd\xdc\xd8 )\xa9\\\xa2PP\x18\x92\x10\x98\x9b\x1b\xd5\xeb\xeaW@I\
\xa7qy\t\xa2\xe7kk\xd7\x8cq\xce9\xe7f\xa5\xf2zk\x8b\xa4$\xc3\xf8\x7fxh4\xd4}\
@y\xfa\x8c\x82\x80,\x0bD\x99\xf5u\xb3Ri6\x9b\x8dF\xa3\xf4\xd3\xce\xee\xee\
\x92\x94T,\x92\x10\x88\xc5F\x9c\xab\xfb\x00\x96\x96(\x08H\x84\xf8a\x82\xe8\
\xd5\xe6f\xd9\xb6=\xcf\xf3<\xcf\xb0\xac7\x9f>\x92$\xba\xb8Pb\xb1a\xab\xa5~\
\x01\xb0\xb8H\xbe\x8f\xf1\x98\xc2\x90\xcae"Z\xde\xde.\xd9\xb6\xeb\xba\xae\
\xeb\x1a\xd6\xf5\xbb\xbd=\x00\xa8V\xefon\xd4\xcf@da\x81|\x1fB\x90\x10\x14\
\x86d\x18\x04\xac\xe4r\x86e\xd5\xea\xf5\x9a\xe3\x14M\xf3}>\x8fHdX(\xa8y \xf2\
\xe81f\xa3\x14\x8dbV\x83\xa6A\xd3\x14\xc7\x81\xa2\xbc\xcd\xe5\xda\xbe?\x18\
\x0cz\xbd\x9e\xc9\xd8\xf2\xceN\xff\xf0P\xe9\x03r\nL\xe7\xcc\x8c<=Mf2\xf87V(\
\xfc\x05\x9e\x045\xa0\xd9,m\xf9\x00\x00\x00\x00IEND\xaeB`\x82' 

def getTTBitmap():
    return BitmapFromImage(getTTImage())

def getTTImage():
    stream = cStringIO.StringIO(getTTData())
    return ImageFromStream(stream)

index.append('TT')
catalog['TT'] = ImageClass()
catalog['TT'].getData = getTTData
catalog['TT'].getImage = getTTImage
catalog['TT'].getBitmap = getTTBitmap


#----------------------------------------------------------------------
def getTWData():
    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\x11IDAT(\x91m\x91\xb1M\x03Q\x10D\xe7\xceg9E\x02\t\x1c8&!\xa2\x05j\
\xb0(\x03\n\x80\x8c.\xa0\nS\x02\x14`Q\x80u\x04\x86\x04\x81@\xb6l\xfe\xcc\xce\
'\xf8`|\x82\xd5h\x92\x9d\xb7\x1ai+\x1c\xdeb32d$c\xad\xc7\xb7\xd3\x03\xc0\x7f\
\xd4\x00\xb8\xba<\x02p\xbc;\xe8\xd5\xf5\xfd|\x11FD\xecL\xcf{Z\xd6d\x96\xf2\
\x8f/&\x93\xa6\x9c\xde[\xfad\xbc\xdf\xefW\xed\xf5\xe2\xeee%Y\xb3\xd6\xfc\xc8\
\x89\x99)\xa7\x94\xc9j42\xd0\xc0\xb0\xcd\x14@&\xbdZ\x89a\xc9\xdfQ\xa6\x9cX\
\x00\x90\x06\x1aH\x11\x98\xaeyq3\x93\xfd\xf4\xfe\xa90mo\xdd\xde\x00\x00\x1a$\
\xd9\x0e\xc5\xf3\xab$3rDH\x1ep\xf1\x9b.\x80d\xa0\x89\xf9\x18\x0fg\xb9m3\x13\
\xa8Ln\xd7\xd8\xf6\xaaT2P\x919%H\x9dP7\r)K*@O*\x15\xb7\x0bt0\x11\nD\xa0\x005\
\x85\xe10\x93P@\x04Y\x91\x90P\\BD\x91\x81j\xd9}$\xfe\xfb\xeef\x05\xe0\x0bISf\
\xe0\xc1\xf3\xe2%\x00\x00\x00\x00IEND\xaeB`\x82" 

def getTWBitmap():
    return BitmapFromImage(getTWImage())

def getTWImage():
    stream = cStringIO.StringIO(getTWData())
    return ImageFromStream(stream)

index.append('TW')
catalog['TW'] = ImageClass()
catalog['TW'].getData = getTWData
catalog['TW'].getImage = getTWImage
catalog['TW'].getBitmap = getTWBitmap


#----------------------------------------------------------------------
def getUAData():
    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\x00\xf7IDAT(\x91m\x8cAJCQ\x0cE\xcf\xfb}\x08\x8a\xc3N\x94\n\xe2f\\\x8e\
\x0bp\xec"\xdc\x86k\x10\x84\xee\xc0\x99\x82s\x1dX\xd0\x97\xe4^\x07\xfd\xad\
\x16\x0c\xe1p\x13N\xd2\xb83\xfb\x92H\x10$\xa4\xe6\x1e;\x0e\x01\x1dq{\r [neR\
\x94\x9cn\xa9Ej\x8ar\xca!G\xf9\xe1\xfe\xb33\x01\xbcm\\\xa6D\xc8U\x84\x1d5K\
\xa3<\xe4(_\x9c6\xbe\xd4\x11\x92K\xa4I\xb9\x8aag9v\xde(\x8fr\x94\xa3\x00u\
\x86\xca-E\xca\xb9\xff\xfd\xc7\x9e)\x87\xe0\x83\xcer\xbd<\xbe\x1c\xf5]rJ!R\n\
)\xe4(\xa5\x145\xe7\xd5\xc9\x11\xe7\x8f\xad^auc\xbf\x98\x81\xd3\x0e{\xfc\xcb\
i\xbaz\x7fZw\x89\xe6\xb0\x07\xe4\xa1t`C\xda\x99\xd0%\x16\xa4\x1d\xb0\x97\xfe\
9\x83\x82"\xe9\x12\x93\x13\xcev\xdb\x80h- a\xcb\x9cmJ\xa2m\x9e\x91P\xced\x9f\
\xb7\x81\xdf\x11\x01\xfc\x00H\x87n\xe8\xf8\xe8Xa\x00\x00\x00\x00IEND\xaeB`\
\x82' 

def getUABitmap():
    return BitmapFromImage(getUAImage())

def getUAImage():
    stream = cStringIO.StringIO(getUAData())
    return ImageFromStream(stream)

index.append('UA')
catalog['UA'] = ImageClass()
catalog['UA'].getData = getUAData
catalog['UA'].getImage = getUAImage
catalog['UA'].getBitmap = getUABitmap


#----------------------------------------------------------------------
def getUSData():
    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\xb9IDAT(\x91U\xd1\xbdkSa\x18\x05\xf0\xf3\xd6\x04\x17Q(\x08\x16\xa9\
\xc1\xc5\xd5M\xa4\xa0\xc5M\xed\xa0\x83 \xd5E\xbcj\x06\'1\x8b\n\xe2\xd0?@\xa4\
\x83\x88\xd0V\x84:tphAAc-\x19,~,R\x0c\x85"$-\xf1&!\xb9\xb9y\xf3\xde\xf7\xf3y\
\x1c\xa4\xa1\x9e\xe9\x07\x07\xcerDT\xac`\x18"\x90\x07,\xc0\x80}Q\xf8\xc0j\
\xd0n\xfd\xb1\x00\x01\x04x\x00Q\xb1B\x14^\xadz\xc7v\xa1\xec\x9ds/?zc\xf4\xf3\
\xf7\xdeZc\x8c\xd1:\xcb2\x95eJ)\xb9\xb44\'\xa2ber\xfa\xf4\xe2\x1a\x05B X\xcf\
\x81\x11\x08\xda\xf3w<B\'A\xda\x83\xecC)q\xedB\xf5[\x05Q\xf1\xd3B\xd9\x1bc&\
\x1f\xdb\xc1`0\xf1\xc0t\xbb\xdd\x93\xf7u\xae\xa4\xd34M\x92\xa4\xd3\xe9\xb4\
\xdb\xed\x10\xaeK\x99\xae\xaf\x7f\x16\xd1\xed\xb5\xb3\xd3\x13se\n\xc4\x81\
\xe1\x1d\x0c\xf3\x06\x8cW_}c\x16JAJ\xd6\x1a\xd6\x8e\xdc\xbc\xfce\xe3\x07\xa2\
\xe8\x9ds\xee\xccC\xd3\xeb\xf5N\x95L\xab\xd5\xdawo\xa7^\xaf\xe3\xd2\xca\xbf\
\xedf\xb3\x19\xc7q\xa3\xd1\xf8Eay\xf9M\x0e\xe0\xf9U\xe1=\xce\xcd\xec\'\xcfGf\
T0\xd5\xf1;\x015:85\xc5Z\xc3\x18\x18\xc3Z\x1f\xbe{\xb5\xbaU\x15\xb5\xda\xd6\
\xd8\xd81\xe7\x1c\x1113\x11\xed\xc5\xd0Y\x96\x1d\xcfc\xf6\xed\xeb\xdc\xd1\
\xf9\xa7\xe2\xfc\x95\x91\x952\xc71\x92\x04RBJh\xcdJ\xc1Z\x1e\xc29*\xdd8\xb4\
\xfd[ln\xfe,\x14N\xf4\xf3\xf9\x03V3\x83\x99\xf8\xffx\xef\xb4\x1e\x05\xb6C\
\xa0\xd1gO\xc4\xce\xad\x8b\x81\xf7\x1c\xb9\x0b\r\xf4\x01\x05(\xc0\x01z\xb7\
\xfd\x0bh\x80b\xaa\xc7\x98\x14\xc8\x00\x00\x00\x00IEND\xaeB`\x82' 

def getUSBitmap():
    return BitmapFromImage(getUSImage())

def getUSImage():
    stream = cStringIO.StringIO(getUSData())
    return ImageFromStream(stream)

index.append('US')
catalog['US'] = ImageClass()
catalog['US'].getData = getUSData
catalog['US'].getImage = getUSImage
catalog['US'].getBitmap = getUSBitmap


#----------------------------------------------------------------------
def getUYData():
    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\x01bIDAT(\x91e\x91\xb1\x8a\x93Q\x14\x84\xcf\xbd\xb9\xb9\xc6B\xb2\x8b\
\xc2\x16\xb2\xf8\x08\xb6\x96\x82/\xb0o`\'\xa8\xdd\x82\x8d\x0f\xb0\xbe\x82\
\xb6\x8a\xa06\xc2\x8a\x88\x9d\x85\x85Xha\x88\n\xb2AYI\xb1\xfc\xca\x8f\x107\
\xf9\xcf|\xc7b\x93(8\xcd\x999\xd5\xc7Lj\xdb\xd6\xcc\xcc\x0c,g\x033\x83\xf5\
\xf9O\xc5\xccjui?%j\x7f\xc7\xd3\xc6\xc3\xb7\xcd\xf1\\X\x08\x93\xe8\x14"\\!\
\xd8\xbb\xf3:5MS\xeb~\xce\xaf\xcc\x04\x97\xa2w-"\x85\xc5Z\xacL\xcey\xf4iR\
\xc0\xe1w\xce\x8a\x90\xd9(\x85\xbf\x1c\xcf\x88\x10!BB\x84\x03\xc4\x99A\xef\
\xd6\xfd\x83R\xeb\xa0\xf4v\xe6\x8b\xef\x81\x0f\xea\xf5E\xf4_|h\x7f\x1d{Gt\
\xa2s:E\xe7tb{\xb3N\xef}IG\xcd\xcf\xcd\xe1p\xb1\xe8"\xa2_\x0b0\x9b\x83\xf1\
\x17\x89%X\xc9\xf9\xfd\xe8s\xd9}rx\xf5rng.B\x00!\x85\x08\x05\x02\x97\tD\x00\
\x1b\xa7\xcb\x8d\xbb\x07\xe5\xc1\xa3o\xdb[\xc3\xc3\x1f\x8b\x15\xc3\x9a\x84UT\
\xa7\x90\xe2\xc2\xd9S\xf3\xc7\xe3\xf4q2=\xbfuN\xe2\xdfB\x96\xc1X}-"JIo\xde\
\x8d\x93]yv\xfb\xe6E\x07\tWt\'\x95\x0bW88H\xe12\x02\x11\xcfw\x9f\xa6\xc9\xd7\
\xa9\xe3\xcb\x19O\x9c9\x8ec\xe0\xee\x98\x01\x86;f\xd9\xec\x0f\xcc\x93\x94\
\xa9E4O\xf8\x00\x00\x00\x00IEND\xaeB`\x82' 

def getUYBitmap():
    return BitmapFromImage(getUYImage())

def getUYImage():
    stream = cStringIO.StringIO(getUYData())
    return ImageFromStream(stream)

index.append('UY')
catalog['UY'] = ImageClass()
catalog['UY'].getData = getUYData
catalog['UY'].getImage = getUYImage
catalog['UY'].getBitmap = getUYBitmap


#----------------------------------------------------------------------
def getUZData():
    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\x01dIDAT(\x91}\x91=K\\a\x14\x84\xe7\x85\xab`\xb1\x88\xb9\xa60`\x08"AHm\
\xbd\x95\xa4\x92\x14\xe9\xd2\x19H\x13\xadR\xa4\xb0\x10k\x7f@@\x08\x04\x7f\
\xc0B\xd8n\x8bt)\xe5\xa6\t\xe9V#+A\xb2~\xb0\x0bq\xd73g\xce\x9b\xe2f\x83E\xe2\
S\x0c\xc3\xe10\xc5L\x026Z\xad\xb7++\xf3{{\x9f\x0f\x0e>\x02\xde\xe9\xec|\xfb\
\xfas\xf9\xf1\xfc\xfa\xfa\x1b\xc0\x01\x03\x0c\x18\xd7&\x01\x1b\xc3\xe1\xbbN\
\xa7[Ug\x11\xb1\xb9\xb9:\x1aiz:]\\\x8c\xf6\xf7\x0f\x9dAW\xad\xa4\xda\xed\xed\
\x02@\xbf\x7f\xddl>:?\xbf^[[:=\x1d\x96\xf7fz\xbd_e9\xd3\xed^\xd2d\x94\x99\
\x93Z\\\x9c\x05\xc6\xc5+|8y\xffd\xd0;\xbb/}\xf9\xe4\x92\x1f\x9b\xcbydzA\x8a\
\x0c\xa3\x1bE\xce\xf2\xc1!\xfai0\xb8i4\xa6\x00\xe4\x9c\x91\x91\x91\xffGJ\xa9\
\xaa\xbe\x17\x11Q\x7f\xe7\x9c\xff\x9a\x7f\x82\x94"\xbc\x08\xc4\xe4pg~\xce)gw\
\xa4\xe7\xc0\xcb\xd7\xbbW\xc7\xbdp\x97Q\xa4\x9b\x8b\x14)\xa3\xd3e\x7f\x9a\
\x9a[z\xb8U\xb5\x8b\xd63\x94O\x7f\x1c]\x9eP\xa4hn&\xa3h2:-H\x99\x8b.-\x97\
\x19\x15\n\x8cA\xf9Bc\x81\xa2K\x1eu\xf8\xa4\xfdp\x97KR\x96B\x00\x12\x9a\x93)\
o\x0fZk\xbdr\xc6m~\x03:<o^H\x87\xb8\xe7\x00\x00\x00\x00IEND\xaeB`\x82' 

def getUZBitmap():
    return BitmapFromImage(getUZImage())

def getUZImage():
    stream = cStringIO.StringIO(getUZData())
    return ImageFromStream(stream)

index.append('UZ')
catalog['UZ'] = ImageClass()
catalog['UZ'].getData = getUZData
catalog['UZ'].getImage = getUZImage
catalog['UZ'].getBitmap = getUZBitmap


#----------------------------------------------------------------------
def getVAData():
    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\x01kIDAT(\x91U\x91\xb1NTa\x14\x84\xe7\xfc\xf7\xbf\xb0\xae\xba\xab\x1b\
\xb6\x104&j\x0c\xa5\x05FH\xac,4\x16>\x8b\xcf\xe0\x13\xf8\x0e>\x81\xb1\xd3\
\xc6\x02cb41\x16\x12\x9a\x85\x86bW"A\x02\xae\xec\x9d\x7f\xc6\xe2\xb2Q\xbezf\
\xce9sb\xff\xeb\x10:\x002\x00\x81`\x91\xa0\x14\xdd;;HWt\x1eJ\x19:\xbaz\xfb%\
\x00\xb8\xc0\x86\x0b@c!\xfaC\xa0\xe3\xf3\x8c\xc7\xe3\x8c\x16N\xe0b\x17\x98\
\xf6\xcc\xd1I\x85\x0e\xd9\xb6\x8bm;"BR\x06\x04\x97\x7fj\x14\x9b\x06\x1di:\
\xe5\xf1\xd1\xd6\xee\xee\xeb\xd3Y\xbdz\xf7Q\xaf\xb7,)I\x84=\xcf.\x16\xad\xc6\
j\xec\xfcc\xffx\xf3\xd3\xab\xbaD\x1f;[\xdf\x9fO\x7f\x7f#\x99 \xc3t\xabvc76\
\xed\xc6ez}\xe5\xf2\xb3\xa7/N\xf6\xf6F_\xfa\xf77\xdev\xfb\x8f%e\x01F\x99{\
\xda\xf8\x99\xa3r,\x9e\x1c\xbe\xf95yw\xab\xf7p%\xae}\xfe\xf8a\xb0|c\xa1\xaa\
\xb3\x08\xb8X\x8dA\x8bgC\x90\xad\xa6\xeen,\xdd\\?\x18m/V?\xd7\x1e<iT&\xe3I\
\x96`\xf1l\r\xcf\x0f\x88l\xcd\xaaj\xe0\xe4\x8bk\xab\x91"\xe5\xdc\x89\x9ad&a\
\x13\xd5\x10f\x98HD9Et"\x12"\x00\\\x18\x0cl\x00n\xfb\x8f\xd1{\xe8\x0f\x04\
\x88\x10AB\x84\x80K\xf76\x85\xa5\xff\xdf\xdc\x1a\xfe\x02S\x96F.k8S\xc3\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getVABitmap():
    return BitmapFromImage(getVAImage())

def getVAImage():
    stream = cStringIO.StringIO(getVAData())
    return ImageFromStream(stream)

index.append('VA')
catalog['VA'] = ImageClass()
catalog['VA'].getData = getVAData
catalog['VA'].getImage = getVAImage
catalog['VA'].getBitmap = getVABitmap


#----------------------------------------------------------------------
def getVEData():
    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\x01fIDAT(\x91]\x91=kTa\x10\x85\xcf{sA\xb6H#iR,!\xc6N\xff\x80Z\x9a@\x922\
\xd8\xdb+"\nIa\x93\x7f\x10\xb4I#l\xf2\x03b\x93\xc0\x16\xf1"laca)\x88_\x10S\
\xa8!"n\xb6\xd89gf,\xee&\xa8\xf0\xf00_\x9cf\x8a\x9f\xe0\xf0\x1bPa\xf92"\x00\
\x00\x01\x04\xe2\x02 \x84\x08\x84\x10B\xbd\xb8\x87\xfd\xe1f\xe7\xb1\xbfx7\
\xbdv\xfd\'\xe0\x99\x0e\xa8\xa4\xa6\xa0*\x99\xa9<\xf7\xd9\x9b\xfd\xba\n<\xb5\
\xbb\xc7\x0fl\xed\xd13\xe0W&\x01\xcf\xe4_X\xa6e\xb2\x94n\x08u\xb3\x8c\x9c\
\x7f\x0e|m\xef\x00\xcf\xb4\xf3\xd4\xc9ik\x80!\x14`\xb0\xb1\xb1pt4\x96 \x06\
\x95\xbd^\xb7\xd3\xa92s4\xd2\xea\xea\'2\xcc\x82\xcc\xb9\xb9K\x83\xc1\xab\n\
\x08)\xc8$\x83\xcc^\xaf\xdb4\xc3\x95\x95\x8fKK\x1f\xfa\xfd\xdf\x07\x07\xf3f\
\xd1"\x05\xa0\x1a\x90;\xa44\xe6\xeeN\xb7i\x86\xdb\xdb?\xcc\xd2,\xb6\xb6\xbe\
\x8f\xc7~\xf8r\xe1\xe6\x8d\xf7m"\xa0r\x1b\xb7\xee\xdf{x\xfa\xe5\xd4\xe5nr\
\xbaZSn!\xcaMA\x97|\xe6\xca\xcc\xfa\xdb\'u\x1f\xaf\xa7t-\xf8\x19d\x92i\x96f\
\x93\xe2b"B^\xfc\xea\x1d\xa0\x0e\xa0\xa20;\x9b$\xe4\x10A\x16\x12\x12ZKpo\t\
\xa0\x8c&\x9f\x9d\x80\x7f\xdb\xffV\x00\xfe\x00\x7f\xf4Zt\x97\xd3\xc4\xb3\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getVEBitmap():
    return BitmapFromImage(getVEImage())

def getVEImage():
    stream = cStringIO.StringIO(getVEData())
    return ImageFromStream(stream)

index.append('VE')
catalog['VE'] = ImageClass()
catalog['VE'].getData = getVEData
catalog['VE'].getImage = getVEImage
catalog['VE'].getBitmap = getVEBitmap


#----------------------------------------------------------------------
def getVNData():
    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\x0bIDAT(\x91}\x91!N\xdda\x10\xc4\xe7O\x9f\x00A\x13$\xe2id\x1d\x86\
\x03 8E]\xaf\xd0 @\xc0U\xdaj\x0eQ\xd5S4\x80"\x88\x866ag\xf6\xfb!>Rx\ta3\xd9\
\xac\xd8\x99\x9d\xec,\xe8\xa5\xc6\xe6\xfc&\x16$\x9d\x9eJb\x0c\x8d\xa1n\xd2\
\xea\x90(\xc1\xe6U\x7f\xb8\xbaZI\x92\xe0\xfaF\xdd\xea\xc6V7\x07f\x98_\xa6\
\x8c\x8b*\xece\xbd\x1e\xd2J\x12\x83\x8d\xed*\x8e\xc3\xae\xf9Y\xb8(O\x82\xec!\
\xad\x86\xb4t+!Q\x87\x0b\xf3\xcf|2\x98\xcbb\xaf\xf8\xfcB\xd0\xbc\xa0\xf4t)\
\x873\xf3\xad\xc0`\x0e\x8b\x13\xf3\xe7\xd9\x92\x92!mI\xa2C\x82\x0b\x17w\xc5\
\xd7\x82\x82G\xce\x8b\xdf\x8fTM\xbc\xb2dS\xa5d*qY|1\xf7\xe6{\xf1\xc3\xff\xe5\
I2\t\x1f\x92i\x11\x9bUqR\xdc\x9a*\x8e\xcc\xb6y(b\xa5\xd5\xadI\xd8r\xb4\xbf\
\x8f\xad\xb4b\xd9\xcb\xdaJdk\'\xfa\x98\xf9Cu\x0fi\xf9\xbb\x19\xe4;\x19\xcfz\
\x02\x8bsUM\x8a:d\x82\x00\x00\x00\x00IEND\xaeB`\x82' 

def getVNBitmap():
    return BitmapFromImage(getVNImage())

def getVNImage():
    stream = cStringIO.StringIO(getVNData())
    return ImageFromStream(stream)

index.append('VN')
catalog['VN'] = ImageClass()
catalog['VN'].getData = getVNData
catalog['VN'].getImage = getVNImage
catalog['VN'].getBitmap = getVNBitmap


#----------------------------------------------------------------------
def getVOLAPUKData():
    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\x85IDAT(\x91eP\xc1\x8a\x82P\x00|>\xd4T\xd2H\x14\xb3B\x92N\x85\x94\
\x97\x0e}B\xa7>:\xe8Z\x97\nR)K\xd4(\x93\xd2\xc8\x97\xca\xdbC\x87v\xb7\xb9\r3\
\xc3\x0cC`\x8c\xc1\x17\xe28N\x92D\xd3\xb4o\x89\xfc\xc7\x1d\xc7Q\x14\xc5\xb2\
\xac0\x0c\x05A@\x08)\x8a\xf2\xdb@\xbc\x1bf\xb3\x99m\xdb\x96e\xd5j\xb5\xe1p\
\xa8i\xdav\xbb-\xcb\xd2q\x9c<\xcf;\x9d\x8e(\x8a\x93\xc9\xe4\x13\x00\x00\x84a\
\xb8X,0\xc6\xbb\xdd\x8ee\xd9,\xcb\xa2(\x1a\x8f\xc7\xf5z]\xd7uQ\x14?\rQ\x14-\
\x97\xcb\xeb\xf5\xfax<\xe286Ms\xb3\xd9\x94e\xa9(\n\xcf\xf34MGQt\xbf\xdf\xa7\
\xd3\xa9,\xcb0I\x92\xfd~/\xcbr\xab\xd5\xc2\x18\xb3,K\x92\xa4$I\x10B\xdf\xf7=\
\xcf;\x1c\x0e\x10B\x8e\xe3\\\xd7M\xd3\x14\x06A\x90\xa6i\x18\x86\xf3\xf9\x9c \
\x08\x86a^\xaf\xd7\xe5r\xe9\xf7\xfb<\xcf\xeb\xba\x0e\x008\x1e\x8f\x82 \xdcn7\
\xdf\xf7\xc9j\xb5\n\x00h6\x9b4MS\x14\x95\xe7\xb9m\xdb\x86adY\xf6\xde=\x18\
\x0c\xca\xb2t]\x17!d\x9a&\x811v\x1cg\xbd^3\x0c\xc3q\\\x9a\xa6\x92$\x05A\x10\
\x04\xc1h4\xca\xb2\x8c \x88\xa2(\x10B\xbd^OUU\x12\x00\xd0\xedveY\xf6<\x0f\
\x00\xd0n\xb7UU]\xadV\x10B\xc30N\xa7\xd3\xf3\xf9\xa4(\xaa\xd1hT*\x95?\xb7\
\xfe\xc6\xf9|.\x8aBU\xd5o\xe9\x07I\xbb\xd4\xc3\x9c&\xc1D\x00\x00\x00\x00IEND\
\xaeB`\x82' 

def getVOLAPUKBitmap():
    return BitmapFromImage(getVOLAPUKImage())

def getVOLAPUKImage():
    stream = cStringIO.StringIO(getVOLAPUKData())
    return ImageFromStream(stream)

index.append('VOLAPUK')
catalog['VOLAPUK'] = ImageClass()
catalog['VOLAPUK'].getData = getVOLAPUKData
catalog['VOLAPUK'].getImage = getVOLAPUKImage
catalog['VOLAPUK'].getBitmap = getVOLAPUKBitmap


#----------------------------------------------------------------------
def getVUData():
    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\x91IDAT(\x91M\x8bM\x88\xcc\x01\x18\xc6\x9f\xff\xcc\xdf\xc7\xbap\x13\
Z\xdar2\xd8\xc3\xb8Hj\x0f\x9c\xe40,\xe5\xe30\x07N\x8a\xd3\xba\xac3\xce\xa3\
\xbd\xae"E\x8a\x1a\xe5\xc6A\xb1J{\xd9\x89\x93\x96B.v\xd7\xc7,\xffy\x9f\xe7}_\
\x07\xb3\xa5~\xfdz\x0e\xbf\x07\xfbv\xe0\xedC\x8c\x003\x80\xff\x07\x81\x01\
\xf0\x07X\x05~\x01?\x80\x15`\t({_\xb0\xd0\x9f\xfe\xfc\xbe|0k=\x8f\xfd\xee)\
\x87\xab\x90\xeaR\x8dL)\xd7\xdc\xefvK\x00\xef\x16s\xe9\xdb\xc7Sgj\xb7nT?\xc9\
C\xf2$\x87\x18\x93\x96fI\x16\xa3\xa3\x01\xd4\x00\x84\xe7\x9b\x05\xbf\xd7\xad\
.]-\x9e\xb8?\xa5\rS\xb3\xe4 \xcd\x86\x90\x01\x94\x00\xce\x1e\xf7\xad\x9b\xb5\
\xfc]w\x1e\xeb\xca4.^cG4\xa7\xdcLfN\xba\x99s\x97\xf3\xd9\xbfCU\xf9\xcd\xfb\
\x9c\xba\xa0\x97\xf3\xaa*\xde\xbe.g\x11\x81\x8c"\xa2\x16Qd\xd4\xc3}\xdd\xa6z\
\xef\x11J\x00\x9f\xbe\xea\xd8\x84\x96W\xac\xd9P\xbbU\x9c\xbe\\\x99Q4#iC\x93\
\x1c\x1b\xeb\xbfz\x8d\x12\xc0\xf39~X\xb4\x03{\xd5n\xe1|\xa7?\x98\xb4\xc1\x11\
\xd2iaL\x9a\x1b\x93J\r6\x08/P\x02\x10\xd5l\xb0\xdd*\xceuVm\xc2\xaa\x83\xc6\
\x8a\x16\xc6\xa0\x05\x99\xa6\xa0\xc2U8\xfa(\x01\xec\xd9\xad\x13GwN\xdd\xfd\
\xbd\xed\xe4\x166H\'\xd7S)\x06\x95R\xc8\xd3=\xdc\xd3a(\x0b\xa092\xbb}\x1c8\
\x0c\x8c\x03s@\x00\x02\x0c\x88\xb5-\x00\x80\x80\x8d\xf8\x0b$\xc5Q\x9b\'}\x7f\
\xc4\x00\x00\x00\x00IEND\xaeB`\x82' 

def getVUBitmap():
    return BitmapFromImage(getVUImage())

def getVUImage():
    stream = cStringIO.StringIO(getVUData())
    return ImageFromStream(stream)

index.append('VU')
catalog['VU'] = ImageClass()
catalog['VU'].getData = getVUData
catalog['VU'].getImage = getVUImage
catalog['VU'].getBitmap = getVUBitmap


#----------------------------------------------------------------------
def getWSData():
    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)IDAT(\x91e\x91\xc1JBQ\x14E\xf7\xd3\x97\x83FBM\x1cX\xd4\xb0\xa18\x08\
\xfa\x01?\xa0Y\xbf\xd1\xcc\x1f\xa9\xdfpX\x81\x10a\x10H4\x90HS\xa2 B\x1a$\x14\
<\xcf\xde\xf7\x9e\x06OS\xf3\xb0\xd9\x93\xbb\x16\xe7\xc2I\x80#,&\x026\xefl\
\x8aa\x04\xfe%\x05\xd0l\x9e\xee\xedo\xd7\xeb\xbbW\x97\x8f\xb5Z\xb5\xdb}\x1b\
\xbf\x8e\x83bQ7\x05\xd2%\x9f\xf7w\xab\x95\x02\x00|wg\xeb\xfc\xec\xda,\x94\
\xcb\x9b\x9d\xces\x89S2D\x0e\xdd\xe847s2\xa9V#P\x00b\x8ch\xb7\x9f&\x93\xac\
\xd18\xe8\xf5\xde\xcd\xdc(\xb3\xe0f\xce\xa9\x9b\xcdB\xce\x84\x10\n\xa3\xd1\
\xe7\xf1\xc9\xe1W\xe6\xfd\xfe\x98\x04M4\xba\x99OmY\x00\x90\x02\x96*+1\xbb\
\xbbx\x18\x0e>6\x14`2\x8a\xcc7pAK\x11H\x03\xee\x11n]/>0P\xce\xfc\xd3\\\xd0\
\xf3N\xc8\x08\xa4\x11HH7\x83\xb4\x02\xad\xd2\x90\\R.\x14%\'\xf1\x07\xadk"\
\x14\x10\x02r\xa1@\xa1Rq\x12\n\x10A&$$\xe4-!\x84<\x11H~V\x0f\x89\xb5\xd3.?\
\x01\xf8\x05o\xd3]\x10"\x992\xd8\x00\x00\x00\x00IEND\xaeB`\x82' 

def getWSBitmap():
    return BitmapFromImage(getWSImage())

def getWSImage():
    stream = cStringIO.StringIO(getWSData())
    return ImageFromStream(stream)

index.append('WS')
catalog['WS'] = ImageClass()
catalog['WS'].getData = getWSData
catalog['WS'].getImage = getWSImage
catalog['WS'].getBitmap = getWSBitmap


#----------------------------------------------------------------------
def getYEData():
    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\x00\xf8IDAT(\x91\x95\x8f=JCQ\x10\x85\xcf\x95\xdb<H@\xac\x02b\x93\x8d\
\xa4\tYN6`m\x99G\x16\xe1\n\\Ev\x11\x08\x88v\x16I,\xee\x999\xc7\xe2\x91g\n\
\x15\xfc\x18f\xce\xfc\xc2\x94\x0f|\xa3\x8b\xbf\x16\xa3\x05 \xa0\x02\xe8\x9e\
\x1e\x01\xd8B\nJG"\xc3\x19\x8ep\xd0\x11\x08\x8a\xe1\xe0\xfb\xf3K\x05\x00Xo\
\xaf\xc8t\xa6\x83`:\xe8\xa0I\x07\xdd\x9a\xd8L\xde\xdc?\x08\xa8\xb7\x9b\x8d\
\x17\x0b\x9cN\xb0-A\xb2\xe4L\xa7l9\xd3JGZ*\x93\xc9\xddg-\xe7\xf3\xb9\xeb:\
\x00\xb6a\x18\xfe\x8dR\xca\xe1p\xa8\x92\x86i\xdb\xa3\xf8\x11\x94"\xa9J\xba\
\x14\xfe\xbco\x17[R\xddn\xfb\xe5ru<\x1e3S\xd2\xe8Gl\x0f\xc5\xe9t\xda\xf7}\
\x01\xb0^\xaf\xf7\xfb=I\x92\xad\xb5\xab\xc0F\x06\x19\x11\x111\x9f\xcfw\xbb]\
\x05@\xc6l6\xe3\xd0`0\x18\x11\x97\x94)\r\x0b\xc3\xb7\xff\xe6\x0bV3a\xa2\xea\
\xf3oS\x00\x00\x00\x00IEND\xaeB`\x82' 

def getYEBitmap():
    return BitmapFromImage(getYEImage())

def getYEImage():
    stream = cStringIO.StringIO(getYEData())
    return ImageFromStream(stream)

index.append('YE')
catalog['YE'] = ImageClass()
catalog['YE'].getData = getYEData
catalog['YE'].getImage = getYEImage
catalog['YE'].getBitmap = getYEBitmap


#----------------------------------------------------------------------
def getYUData():
    return \
"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x11\x00\x00\x00\x0b\x08\x06\
\x00\x00\x00\x99 f\x07\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
\x01'IDAT(\x91\x9d\x91\xbdJ\xc3`\x14\x86\xdf$_C\x9a\x984E\xab\xc1A\rEQ\xc9\
\xe2\xe0\xe05\x88\xa3\x93\x8b\x827\xe1e\x88\x83\x9b\xae^\x85\x93\xf0!B\xa7\
\x06\x1c,U,\xda\x14\x0bI%6i\x93|.\x1a4\xa5M\xf5\x19\xdf\xc3y8?\xdc\xc9\xea:3\
e\x05\xff\xa5\xf9\xe1\x83\x98\xb2\x02K+\xfd*\x84$\xc1\x90D\x98\t\xc4\xa9D$\
\x1b<\xe8@\xb8\xd2\x03_\xe4 4$\xacu\x92|\xc9U\xa4\xd6g\x87\xfa\xfbw\xb0\xbbT\
5\xe7\xcb\xdd28\xc05\xf4\xdey\xa7\xd5\x0c\x86Q<N\xd0\x8d\x12\x95\\\x1b;\x16\
\xe6\xaaix`\xba\xf0^=0\xf0\xd0\xcc\x85\xca]\x7f\xa3r\xefs\xe3\xc7xk\x80\xcff\
\xbe\xae\x83\x0bE(q\x11\x03c1w\x15\x00\xa3\x12\xdei\xa3\x00@\x94$\xc4/-\x04\
\xc9\x84)\xbe \xfb\x9bb\xddX\x96\xd2\x9b\xf0\xcf\xb5m_\x90I\x9f\tP\x1ei\xb2g\
\x1d\xdfN\x12\xb4\x9fD\x15\x94R\xf6\x93\x81\xeb\xb1\xda\xc5%\xbb9=c\x81\xe3\
\xb0<(\xa5l\xe4\xc5\x85\x92\x86\xad\xa3\xc3\xa9n\x91\xaec\xdb\xf6\x9f\x1a\
\xb2\xd8\xb6\x8dO>1\x8eT\x1c4\xb0\xeb\x00\x00\x00\x00IEND\xaeB`\x82" 

def getYUBitmap():
    return BitmapFromImage(getYUImage())

def getYUImage():
    stream = cStringIO.StringIO(getYUData())
    return ImageFromStream(stream)

index.append('YU')
catalog['YU'] = ImageClass()
catalog['YU'].getData = getYUData
catalog['YU'].getImage = getYUImage
catalog['YU'].getBitmap = getYUBitmap


#----------------------------------------------------------------------
def getZAData():
    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\xd3IDAT(\x91M\xc6OH\x93q\x1c\xc7\xf1\xcf\xb3\xfd\xb6\xb6\xe7\x19\
\x1a\x9a\rJ\x91`5\x0fu(B\x84\x92\xa4\xa0\xa0 \xa1\xa0\xaeu\x89":\t\xf3RF\x88\
P\xb7\xacnA\x1d;HPF\x10EDT\x82)\xc1\xeaP\x1e\xb2y\xc8\x9e\x9c9d{\xf6\xe7\xf7\
\xfd\xf3\xeb A\xf0\xe2\xcd\x1b\x98\xe8\xc4D\xfb\x897\xa3\x0b\xc5\xb9j>/\xc0\
\x06\x02Z@\x03\x88\x80*\xb0\x0eT\x80?\x80w\xe3\x1dl\xe2\x1e\x94\xb3\x1d\xdbO\
m\x1d\xecz\xfd\xde|\x98\x81\x90c\x06\xb3#r\xff\xb56=m\xf6}C\xff\xd9\xea\xb5\
\xf9\xda\xd2\xd2\xef\x8f\xe1\x97\xd1\xa1\xf3;\xeb533\xe7J\x8b\x8e\xc8Yrd\x9d\
\xb5\x8e\xc8\xeb\xe9Q\xc0\x030\xfbvlG~e\xfc\xab\xff\xabiD\x1a#{/\xe6\x92\xed\
\x1d\x8b\xcb.\x8a\x9c\xaaSq\xa2N\xd5K\xfb\xebSS\x1e\x80B\xa1\xb0\xbb/\x1c\
\x1a\xc4d)\xfd\x93\x13k\xb6%\x0e\xa9xJ\x94I6\x109\xee\xced\x9f\xdc\x994\x00\
\x98\xe5\xe9\xf3\xa8\\\x89\x17N6n\xfdH\x95\xd5or\xbdZ\r\xad\x90\x15KBV\x89\
\x847I\x0b!\x0c\x00\x11>z8v\xe4\x90\xde/%K\xadD\x93#v\xea\x07\x9dIQ\x12"aV"\
\xe5\x8c\xbf\x05\x19\x18\x00\xc3\xc7\xbc\xbe=\xde\xcd\x85\xe0s\xd5X\x1b\xdd=\
x=\x88\x05\xab\xdf\x83zMD\x9c\xaaSu\xa2\x9a\tL\xf7\xae\x0b\xe6\xe18\xf2\xfd\
\xe6\xcal\xdbj\xc4H\xd0\xc8\xfes\xaf\x1e%\x9e=\xae\x84\xe5e"\xb5\xe4\xc8*\
\xb32k.\x97.\x16_\x1a=\x8e\xab\xc5\xc0\x8f\xc5\x07z\xbb\xcel\x1b~\xf1 =\xff\
\xa9\x16\xb4\xa1\xd7O\x13)\xb3cV\x11\'\xa2"\x00\xd4\xc3%\x80\x91\x1d80\xb6\
\xf9\xf6\xe5\xd3+@\x08(\xa0\x80\xfd7\x0c0\x00\x80\x81\xe4_\xe0B._\xd7\x89\
\x0c\xe6\x00\x00\x00\x00IEND\xaeB`\x82' 

def getZABitmap():
    return BitmapFromImage(getZAImage())

def getZAImage():
    stream = cStringIO.StringIO(getZAData())
    return ImageFromStream(stream)

index.append('ZA')
catalog['ZA'] = ImageClass()
catalog['ZA'].getData = getZAData
catalog['ZA'].getImage = getZAImage
catalog['ZA'].getBitmap = getZABitmap


#----------------------------------------------------------------------
def getZWData():
    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\x9aIDAT(\x91M\x91?h\x93q\x14E\xdf/\xfd\x9a\xf8\'\xd1I*\xd2R\x03u\
\xa8\x82.N\x0e\x0eJ\x91\x12h\xc0\xa1B\x04\x11A\\\xd5\xb1\x82\x83\x93\xab:U7\
\x87\x82"\x88]2hE\x85\xa0NE\x97L\x1d:\xb9X#1_\x93\xbc\xfb\xde\xbb\x0e5\x12\
\xb8p\xcf|Njo\xb7\xe7\x97\xe7eI\xc4DB$Dl\xc4*b":\x06EI\xf9\x9f\xbc\xb4\xbf\
\xb4\xda|0s\x1a\xce\x08z\xd0\x83\x164\x0f\xf3\x80\xd3<\xe0aF\xdc\xf9\xb8\x9e\
\xf2<?0Y\xf2\x027\xde\xdeZX\xe83A\xc4I\x8cMI%\x91\xd2L\xb7\xdb\xccD\x84\x13\
\x0f\xf3\x17\xe5\x8b\xcb\xabk\xf7n\\\x88A!)\xcd\x02\xa0)M\xc3@h\x18\xb2)\xb4\
\x1fI\xd6}\xbcR\xa8\x1f\xaf\\\xf9\xf2\xfb\xe9\xaf\xc5\xe9\xe9\xd7_\xb7N\xf4s\
\x07\x02 \xd4\xa1\xae\x08\xa8\x03\x07{X\x13I;\xad\x8dlk\xb3\xdc\xf8L\xda\xee\
\xfb\xc6\xe4\xf9\xa5\xc5Z\r\xc3!\x00U\xd5\x7f\xa7\x00\xaa\xd5j\xab\xd5\xca\
\xb2\x93g\xfd\xfb\x07\xd2v?\x1d.\x9c\xab\xbd\xbc^\x7frd\xe0@@\x03\x08(\r\x01\
\r\xc3\xbe)\xbc\x13\xc9B\xe2\xd0\xcd\xfb\x11\xc13\x9d\xe7\xb7\x1b\x97&zYR\
\x06B\xc0\xa4\x91\x10I\x99\xc0\x82\x15\x8b6\'\x92:\x9dN\xa5R\x19\x0ez\xebo\
\xae^\xaew\x98)\xa9\x8c=9#K\x02\xa1\xa74\xb7\xf3\xf3[\xea\xf7\xfb\x03\x0c\
\x9f5\xef\x1e=5RN\x8b\x80\x13\x16\x16\xfe\xbf\x89\x93\xbe\xf2j3m\xff\xd8\x9e\
=6+\xd7Dz\xa3\xa8:\x8a=\xce{\xed\xcb\xf2\x17\xc6\xbc\\0\x92\xc2\xa7\xad\x00\
\x00\x00\x00IEND\xaeB`\x82' 

def getZWBitmap():
    return BitmapFromImage(getZWImage())

def getZWImage():
    stream = cStringIO.StringIO(getZWData())
    return ImageFromStream(stream)

index.append('ZW')
catalog['ZW'] = ImageClass()
catalog['ZW'].getData = getZWData
catalog['ZW'].getImage = getZWImage
catalog['ZW'].getBitmap = getZWBitmap



Generated by  Doxygen 1.6.0   Back to index