wxPython/wx/lib/art/flagart.py

   1 #Boa:PyImgResource:
   2
   3 #----------------------------------------------------------------------
   4 # This file was generated by famfamfam_flags.py
   5 #
   6
   7 """
   8 See: http://www.famfamfam.com/lab/icons/flags
   9
  10 FamFamFam Flag icons are available free for any purpose
  11 Copyright Mark James (mjames@gmail.com)
  12
  13 This module is (c) 2006 Riaan Booysen and licensed under the Python license.
  14
  15 """
  16
  17 import wx
  18 from wx import ImageFromStream, BitmapFromImage
  19 import cStringIO
  20
  21 catalog = {}
  22 index = []
  23 class ImageClass: pass
  24
  25 #----------------------------------------------------------------------
  26 def getAEData():
  27     return \
  28 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
  29 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
  30 \x00\x00\xddIDAT(\x91\x85\x8e\xb1M\x03P\x10C\xdf\'\xbf\xa4\xa3\x8a\x04]\x98"\
  31 %\x1d\xf3\xd0EL\xc1\x14i\xb3I6 \x12L\x80h\xce\xbe;\x8a\x04\x01E\xc8\xd3\xc9\
  32 \xba\xc2\x96=\x9a\x1f\n\x16\xcf`0\x14\x04\x18\xe2\xcf3\x016\x1b\xa0\xabF\xd5\
  33 \xd3c\xba2\xcbn\xbb\xec\x92\xd2.\xa9\xac\xd4\xeee7\x01\xe8~{\'\x93\xcc\xd7\
  34 \x0fe\xa6ZJ\xa9\xa4TdD\x85Rw\xd7w\xa7\x86\xae>\xba[\xda>l\xfb\x0cc\x8c\xc3\
  35 \xfda\x16\x8cL\xec\xb6\x91\xcf\xb9\xbb\x1b\xa8\xaa\t\xe0l\xe9r`\x0c\xdb\x13\
  36 \xe8t\xdb\xad\xf8?0\xba\x81Y0\xa4\x8e\xc0\xee\x88\x7f\xf6twU\xcd\x82\x85\xdd\
  37 \x12RK\xeb\xf5:"$\x9dTR\x84-;W\xab\xd5~\xbf\x9f\x05W2\xcbeK8o\xad#\xb6\x8fj;\
  38 \xbf\x01\xc6\'\xd4\xaf\xbb\xe1\x02_z\xc6i\x06\x81\xb8\x0e\xd7\x00\x00\x00\
  39 \x00IEND\xaeB`\x82'
  40
  41 def getAEBitmap():
  42     return BitmapFromImage(getAEImage())
  43
  44 def getAEImage():
  45     stream = cStringIO.StringIO(getAEData())
  46     return ImageFromStream(stream)
  47
  48 index.append('AE')
  49 catalog['AE'] = ImageClass()
  50 catalog['AE'].getData = getAEData
  51 catalog['AE'].getImage = getAEImage
  52 catalog['AE'].getBitmap = getAEBitmap
  53
  54
  55 #----------------------------------------------------------------------
  56 def getAFData():
  57     return \
  58 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
  59 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
  60 \x00\x01mIDAT(\x91U\x90\xbdNUa\x14D\xe7\xe0\x01\x01\x7f\n\t\x02%\x15\xe1\x05\
  61 (\xa9-\xedi\xe05,\xef\x1bX[\xf2\x04t\xc6\xa8\xb12\xb1\xd2\xc2\x88\x891\xc6N \
  62 \xc1\xe4&\xdc\xb3gf\x7f\xdf\xb6 &\xba2\xed*f\r\xfb\xfb\xfb\xf3\xf9\x1c\x00\
  63 \x00I\xbf\xae\xae\xfa\xf2r\xb7\x01$\x00\xe0\xd9&\x9e\x1f\x03\x01\x08\x00\xc6\
  64 \xeb\xeb\xeb\xd9l\x06\xa0\xf5\xd6[\x87=d\xbbc\x95\xbdbw\xe9\xe9ny\xefFMl<}q:\
  65 \x8e\xe3\x08\xe0\xe2\xf22\xed\xcc,\xbb\xa4\xa2J,\xb2\x93\xbf\xef\xd6\xb7\xed\
  66 9\x1d\xdb\xeb;\x10\xc6\xde{k-mgZ*\xbb\x80~r\\-\xeb\xcd\xbb\xfa\xf0\xde\xae\
  67 \xc9\x93L%\x11X\x92\x94\x99\xb2EJ*\xb2\x8e\x8e\xf4\xf6\xb5\xce\xce\xfa\xe1a\
  68 \x0f\x9a\xa49e\xb0\t\x0b\x8c\xb1Xd\xa6%\xc9d\x94\xd4\xd7V\xf3\xe0\x00S\x0c\
  69 \xab+\x15\x91\xd1\xa7\x9c\xc2d\x12\x81\xf1&\xc2\xb6$\x92$\xbb\xd4~|_\xda\xda\
  70 \xe9\xf7\xee\xe7\xf9\xd7a\xb1\xb0\x11\x19J1\taD\x95\xed\x88\xb8uzD\xbd|\x15\
  71 \x8f7\xcb\xb9\xf2\xf9\x1cd\xaahF\x86\xbb!\x8c\xb7\xf9%E\x04\xc9\x8a\xa8/\xe7\
  72 k\x1f?u\xb2G4\xd2D\xb4I-\xdd\xfe\n$\x1fml\xdc\x9e\x06\x05q\x90\x06r\xb0\x97\
  73 \xa4\x87[\xd8}\xb0\xe1t\xf6\xc4\x02\x03\xfe\xe7'\xd0\x81\xfcgO\x80\x8b= \x80\
  74 \x04\xd6\xf1\x07\xfbEiS4\x8b\x8d>\x00\x00\x00\x00IEND\xaeB`\x82"
  75
  76 def getAFBitmap():
  77     return BitmapFromImage(getAFImage())
  78
  79 def getAFImage():
  80     stream = cStringIO.StringIO(getAFData())
  81     return ImageFromStream(stream)
  82
  83 index.append('AF')
  84 catalog['AF'] = ImageClass()
  85 catalog['AF'].getData = getAFData
  86 catalog['AF'].getImage = getAFImage
  87 catalog['AF'].getBitmap = getAFBitmap
  88
  89
  90 #----------------------------------------------------------------------
  91 def getALData():
  92     return \
  93 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
  94 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
  95 \x00\x01\x80IDAT(\x91M\xd1?\x8fMa\x14\x85\xf1u\xde\xf3r\x1d\x17\x99\x8c\x89\
  96 \x98h\x14\x12\x89D\xa5\xf41\x90\xa8T\xd3\x88f\n\x8ai\x94\xa2\x11\xa2\xd1\x8c\
  97 \x86\xda\x17\xd0*4:\xbe\x82?\x13\x93\xeb\xba3\xf7\xcey\xf7Z{o\xc5\x90h\x9f\
  98 \xe6)~\xdd\xe7\x015\x80\x02\x00U\x10Q\x81\x118n\x06\x08\x10\x10@\x00#P+\xb0\
  99 \xf9\xe29\x80t\x8f\x88\xea\xbe\xfbky{(\xc5\xfd\xf5\xfe\xe1\xfdi\xefR'\x0b2\
 100 \xc8/\xaf\xdeT\x00\x00\xb4\xf7\xbd\x0f\x7f;[\xdd\x19\xca\xf5\xe5\xf8x\xb6\
 101 \x94\xd9\xdd\xa1\xb3\xfdx\xf6s\xb1=-2;yq\xd3\x80\x1a\x81tO\xf7\x94n\xf4\xb9\
 102 \xf3c1\xb6\x96\xb4\xd3\xd2\xcb\x83Fk\x0f\x86>\x8ca\x16\xa2\x80R\x0c\xe9\x9ed\
 103 \x8a\x9f\x0e\x8f.\x85\x8c\\6\xfbz4\xb6\xb1m\xb8>,\x96\xd1,\xcd\xc2X\x80\x82D\
 104 \xbaBL\xea\n\x1c\xe4\xc3i\xd7Zk\xad\xed\x9c-kaW\x93a\xcd[K\x12@\r %P\xee\xbc\
 105 \xd6\xf9\xe5I\xbe\x9b\xad*M\xd6\xde\xcfck\xd2M\x94aL\x1aH\x03\x8a\x01\xa0\
 106 \x92\xa6\xd6\x06\xd9\xd3\xbd\xdf\xb7&9\x1f\xdb|l\xf7Nu\x8f\xbe\xcd\x07Y\xd2`\
 107 \x16\xae\xd5\xf1!\x9cA\x0b3\x98=9\xd7\xf7\xe2\xcd>\x0fJ\x9c\x11w\xd7O\xb8Y\
 108 \x92\xe9\n\t@\x05\x90T\xbfq\xa1\x90A\x82\x16\xd4\xf6\xda\xf9$\xc3\x19R\x91@\
 109 \x8f`\xba\x02\xe8>\x02\x00\xe2?Q\x01\xf6\xcf\xf5\xaf\x12`\x00\x80\x11\xf8\
 110 \x03e\xfaB@$q9K\x00\x00\x00\x00IEND\xaeB`\x82"
 111
 112 def getALBitmap():
 113     return BitmapFromImage(getALImage())
 114
 115 def getALImage():
 116     stream = cStringIO.StringIO(getALData())
 117     return ImageFromStream(stream)
 118
 119 index.append('AL')
 120 catalog['AL'] = ImageClass()
 121 catalog['AL'].getData = getALData
 122 catalog['AL'].getImage = getALImage
 123 catalog['AL'].getBitmap = getALBitmap
 124
 125
 126 #----------------------------------------------------------------------
 127 def getAMData():
 128     return \
 129 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 130 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 131 \x00\x01\x13IDAT(\x91UO\xbdN\x9bA\x10\x9c\xfb|\x95\xddR\xa0\x88\x967\xa0\xcc\
 132 \xd3!\xaaH.\xd3$\xb4<\x1a\x12\n\x92\xf5a\t\x12n\xe7\'\xc5\xd9\x90\xacV\xa3\
 133 \x19\xed\xccj\xb7\xd5\xf55\xd6\x15\xb3l\x8fa\x12c@20\x1bgb\xa0\xe3pX\xee\xee\
 134 \x00\xc4F\xb2\x9166\xc8H\x99(\x81\x0c\t\xe9\xb8\xdfw,\x0b\x90\xfcz\x86\x14\
 135 \x19>\x8dC\xa6\xea\x14\xabBU\xbb\xbc$\xd0\xb1\xaeq07I\x98\x8e\xe9&\xc3\n\x99\
 136 "X\xa92\xd0/\xb6?ny\xf3\xc47\xcbdH\x93\xaa\xf2\xbf\xa4\xcaU\xfaR\xbb\x9fx\
 137 \xefc\xd0\xb6h\xd2\xa2\xeb?\x9f(\xb3\\\xa5)\x81?}\x8c\xcf+>n\xa9\n\xe9\xaaHs\
 138 \xfd\xfc\x1f\x00\xda\xef\xef\xe8_\xbf\xe5\xf51a\xcc\xa8>\xd1eU,\xb8b.\xbb\
 139 \xab\xa7\xfb\x87\xee\x050\x13\xc6\x15}d*.Oi\xc2\x8c\xe9\x18\x1d\xddGd\x08\
 140 \x9b\x0b\x80\x00[#\xda\xc9\xd1\x16\xb5\x08R,\x83x\xa7W\xb4\x97=\xf0\x06\x0f\
 141 \x98g$x&\x98\x92\x80a\x02[\xfc\x05\x18\xe6\x87\xcd\x06u\' \x00\x00\x00\x00IE\
 142 ND\xaeB`\x82'
 143
 144 def getAMBitmap():
 145     return BitmapFromImage(getAMImage())
 146
 147 def getAMImage():
 148     stream = cStringIO.StringIO(getAMData())
 149     return ImageFromStream(stream)
 150
 151 index.append('AM')
 152 catalog['AM'] = ImageClass()
 153 catalog['AM'].getData = getAMData
 154 catalog['AM'].getImage = getAMImage
 155 catalog['AM'].getBitmap = getAMBitmap
 156
 157
 158 #----------------------------------------------------------------------
 159 def getARData():
 160     return \
 161 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 162 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 163 \x00\x019IDAT(\x91M\x91\xbdNUQ\x10\x85\xd7>l\x0f(\xa1\xc0\x1b\x0c\x8d\x85\
 164 \x95\x11K\x13J\x1a\x94\xc4G\xf0\x01lH(\xad\xa9y\x1ebl\xb4\xf3\xe7\rhL\xb0&\
 165 \xb9\x91h.r\xb2\xef\xcc\xb7,\xce\x81\xdc\xd5\xcc\x97\xc9\x9adfMy\xf7\xc3\x8b\
 166 \xd0(DC\x84BjA\xc0\x104h#\x04}\xa7\xfa7\xf4\xfe\xd9\xe8\xb6]\xb0\x90\xc0\xe9\
 167 \x92\xac\xa5\xba\xc4\xe0\xb4\xd3>\xf9\xbe\xa8Ch\x89\xae\x97\xc6\xc2J;\x11v\
 168 \xe0\xc0a'\x13\xcf\xd6\x8b\x1a\xf5\xf4\xe9\xfc\xc5\x93\xd9\x12Y\x92\x8de\x19\
 169 l\xdb\xb2\xf1\x88\xd8\x0f\x8av^\xce\xeb\xf3-f\xbd$\xd9\x96e\xd9\xb7_rq\x8e\
 170 \xa3\xdb|\xeb\x8d#\xdf\xa9\x14\xed\xcf\xd4\x8d\xe7N\xbd\xb1\x0e\x9f\xe1\x97\
 171 \xf3\xd2\xff>yU\x12PW\xdd\x1a'\xfa\x03\rs\xa9y\xe3p\xd5_l\xa0^\xfcao\xcb-m\
 172 \xebn\xdd7~\xf4\x1a\x1b\xcc\xcd\xe4\x06\xf5\xd5\xdf\xe6Y\x8f\x7f>\xfe\xb0\
 173 \xa6\xab[\x07\xba\x0f$\xefSbJ)\xd1\xeeC\x9d}\xdd\xae\x1d\x14u;\xebS\xa0i%JJZ\
 174 \x81\xb0@\xe9\x92\xd8\x92Dy\xf5\xf1\xe6w\x9b\x1e9\x04C(A\x81\x1a\x02\x8d\x1c\
 175 H(\xa4^\xff\x01\xf6\x01p\xe7$\xc8U\xac\x00\x00\x00\x00IEND\xaeB`\x82"
 176
 177 def getARBitmap():
 178     return BitmapFromImage(getARImage())
 179
 180 def getARImage():
 181     stream = cStringIO.StringIO(getARData())
 182     return ImageFromStream(stream)
 183
 184 index.append('AR')
 185 catalog['AR'] = ImageClass()
 186 catalog['AR'].getData = getARData
 187 catalog['AR'].getImage = getARImage
 188 catalog['AR'].getBitmap = getARBitmap
 189
 190
 191 #----------------------------------------------------------------------
 192 def getATData():
 193     return \
 194 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 195 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 196 \x00\x00\xe9IDAT(\x91}\x91\xadnBA\x14\x84\xbfmoj\xd077\x08\x1c\xa65(\x1e\x0c\
 197 \x8d\xe7\x810\xbc\x01\x9e\x17@\xb5\x82P\\k\xf6\xfcL\xc5\xde\x14hH''_FL6g\xe7\
 198 \x14qU\xde\xfb\x87S\x04\xac\xd7\x802\xc9$B\x1e\x84\xcb\x1dw\x99\xe9\x86_\xdb\
 199 m\x07\x80\xf4\xfeA\x04\x112k\x1c\xa7\x9a\xac\xaaV\x99\x95\xd9,\xa1c\xb9\xd4\
 200 \xeb\x1b\xfd\x80R\xeeD(B\xeer\xbf\x1a\xf7Z\xeb\xcb0\xe4nWN\xa7S\xdf\xf7\x80$\
 201 \x84\xd0\x1f\xd5Z\x1b'\x93\xc9\xe5ri+\x8d\xa9_\xf3X \xa9\xbb\x86\x1e\xbe\x7f\
 202 \x9b\x972\xb3\xd8bQV+\x9d\xcf\xdcl,\x0f\xc5\xdd7\x88(\xc3\xf0\xb9\xd9ty8<\
 203 \xef\xf7:\x1e\x19k\x19;\x19\xd9\x8c\x1b\x1e\xcc\xe7@\x97\xf0d\xcet*3<p\xc3\
 204 \xac\x98\xe1N\xa3{k\x9c\x88\x84\xf2}\x7f\xc8\x7fn\xdc\xf4\x03|\xd6ZM\x8alr;\
 205 \x00\x00\x00\x00IEND\xaeB`\x82"
 206
 207 def getATBitmap():
 208     return BitmapFromImage(getATImage())
 209
 210 def getATImage():
 211     stream = cStringIO.StringIO(getATData())
 212     return ImageFromStream(stream)
 213
 214 index.append('AT')
 215 catalog['AT'] = ImageClass()
 216 catalog['AT'].getData = getATData
 217 catalog['AT'].getImage = getATImage
 218 catalog['AT'].getBitmap = getATBitmap
 219
 220
 221 #----------------------------------------------------------------------
 222 def getAUData():
 223     return \
 224 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 225 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 226 \x00\x02\x0bIDAT(\x91M\xc7OHSq\x1c\x00\xf0\xef\xdb\xdehK\x9d\xd3\xb9\xb6i\
 227 \xcf\xb6\xe5"\xe7\xa6\x1db\x0b\xb3\xc2\xb2\x81\xd9""(\xe8\x94\x15\x1d\xa3\
 228 \xa0d\x87.E\xc1@\x11:fQ\xd0%\xb0F\x041\x85(\xad\\D\r\x13L\x02\xdd\x16\x195\
 229 \xdb\xd2ml{\xbf\xf7\xfb\xdbU\xf8\\>\xd2\xc7\x91\xdb3\xc6\x8e\xe8\xd4\xfaX1.s\
 230 ~\x85\x87\xaf\xb7\xfe<\xbc\xb7}\xf0~\x01\xaaE\x00\n@\x07/\x0c$\x1e\xbe\x04X\
 231 \x07\xc0\xd2Pd\xecQ\xb4\x8f\xd8\x154\x9f\x12H\x95vx,6\xcb\xeb4\xfa\xb2\xf8\
 232 \x9bQ\xaebr.\x12\x90e)\xb3\xba\x91\x98]y2:.\xa5L&\xe7\x9d\xbb\xfa\xc2_R.sM3\
 233 \xd4\xd7i\\\xaa\xa98f<P\xa4\x12FXq6\x86\xf7\xbbc\x13s.\xa5i\xf2\xde\xb8\xee\
 234 \x9d\xff\xb8\xae\xab\xc7\xe8\xebdV\x1b(\xae\xad\xc1 Q\xdc\xe9\xed\xdd\x88\
 235 \x8a\x13\xfd\x1d\x00\xf0=\x9b\x8fM\xccE/\xf79\xacu\x005]\xf1\xf40X\xad/\xb8\
 236 \xebO\xbd=g\xb0\xc4\x9b\x83z\x7f\xa0dn9r\xd0\xab\xd8\x1b\xae\x0e\xefS\x119{\
 237 \xccg\x90\xa5\xa3\xbdn\x00\xa4\xf7K\xad\xf9\x06\xc7L\x16\x91\x1a\xcaVuSK\xa5\
 238 \xe5\x8a\xde\xc2\xd5\xe7\xc9_^O\xcbd\xe2\xdbZ\xbeR\xd8P\x9b\x1a\x8dO_-\xae|}\
 239 \xaf\xff\x9c\xe9\x0c\x0ctW\x8b\x95\x0c1e\xf0\x16\x99\xe2\\\xbe2\x9f#L\x88dju\
 240 \xed_E\x08qf\xa8\xebq|\xc1d4d\x16\xde\xe8\x00(PN(?u\xc8s\xf3b\x08\x13F\x19\
 241 \x07\xce\x08\xa6\x9cs\xc1\x84\xa6\xd1\xd1\x07\xc9R\xb9\xc6\x19\x03\xa0:\x00\
 242 \x8c)\x13B\x84\xf6\xb4\xb5;\xcd\'\xc3\xbb5L0\xa1\x98PL\x98\x8aI\x9b\xc3<r\
 243 \xa9W#\x8c1\x01@e\x00\xcc9on4M\x7fH\xf7\xec\xb2\xcd~\xfa\xa18\xcc\x9a\xc6\
 244 \x98\xe0\x94\n\x15\xe1k\xe7C\xbe\x9d\xdb4\xcc\x9eM/\x01 \t \x02@\x01\x10\x00\
 245 \xde\x84n\xae\xb7\xff\xc6\xf2\xdb[\x00\x1c\x00\xfe\x03\n\xf8\x1b\xa4\xf3\x04\
 246 q\xa6\x00\x00\x00\x00IEND\xaeB`\x82'
 247
 248 def getAUBitmap():
 249     return BitmapFromImage(getAUImage())
 250
 251 def getAUImage():
 252     stream = cStringIO.StringIO(getAUData())
 253     return ImageFromStream(stream)
 254
 255 index.append('AU')
 256 catalog['AU'] = ImageClass()
 257 catalog['AU'].getData = getAUData
 258 catalog['AU'].getImage = getAUImage
 259 catalog['AU'].getBitmap = getAUBitmap
 260
 261
 262 #----------------------------------------------------------------------
 263 def getAZData():
 264     return \
 265 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 266 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 267 \x00\x01nIDAT(\x91M\x90\xbdjTa\x18\x84\xe7;9\xbb!k\xc0F$?D\xb3j\xab\xa0\xb5m\
 268 n"\x17\xb0w`\x15\xbc\x834\xa6\xdb\xe0%h\xe3\r(.\xa8\xd8\tY\xbbUD\x11m\xd4\
 269 \xc4D\xf7|\xef\xcc\xbc)\xd6\x80\xc3\xc3\xf0\xc0tS\xf0\xe85\xe6\xc4"\x06h\x98\
 270  @\x82\xfe\xd7\xd5 Q\x89\xb6iq\xca\xbd\x9d!\x00\'\x9c\xa9L\x1a\xb2\x99I\x9bF\
 271 \xc8\xb4\xc3\x19\xcag\xe3W-\x06\x03,\xb5_\xceB\x862\xc3\x962\xa4H\x843\x9cU\
 272 \xaev\xc8[\x97\xfa\xe8\xaf\x96I)7\x0e\x0e\xea\xb7\xefiA2\x99\xa4I\x93\x19a\
 273 \xd2\x11\x8eH\xb2\xbf\xb6\xf6r<n\xd14 \xa1H\tA\xcd\xff^\xdd\xdd\xedml\x1e?\
 274 \x7f\xd1\xbb\xbeu<\x99\xfc\x99N3hFFm\x80\xc6\x92\x13\x96\x93\x12\xb9<\xbc\
 275 \xd9\xdb\x1e~\xde\xdf\x1f\xdc\xbb\xbb|m{\xe5\xf6\x1dQ"E\xd9I\xa0\x01P\x16\
 276 \x0fT\x96Pw\xf4\xbe\x9b}\\\x1f\x8d~>y:\x9f\xcd\xce\xde\xbc-\x1dKe\xe9\x88J\
 277 \x03m\x05$J\x91\xa2\x19n\xf2\xeb\xe3\xc3\xaca\xf1\xd7\xf4\xc8\x11^L\xe6\x92y\
 278 \n\xb4;\x0f1\xba\xaf\x0f\xbf\x15bXU\xac\xaaQ\xa3BaV3L\x8a\xb4n]\xf6\xbbOhq\
 279 \x82\x08\xae\xf7\xaf\x84H\x93b\x98\xd1#\xcd\xb0(1)I)u\xc2\x0f\x14<\x00N\x00\
 280 \x02\xf5\x02\xfe\'\xbc\x10\x03\x04Vq\x0e\xae\xdce\x0f\x0f\x8e\x9dx\x00\x00\
 281 \x00\x00IEND\xaeB`\x82'
 282
 283 def getAZBitmap():
 284     return BitmapFromImage(getAZImage())
 285
 286 def getAZImage():
 287     stream = cStringIO.StringIO(getAZData())
 288     return ImageFromStream(stream)
 289
 290 index.append('AZ')
 291 catalog['AZ'] = ImageClass()
 292 catalog['AZ'].getData = getAZData
 293 catalog['AZ'].getImage = getAZImage
 294 catalog['AZ'].getBitmap = getAZBitmap
 295
 296
 297 #----------------------------------------------------------------------
 298 def getBEData():
 299     return \
 300 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 301 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 302 \x00\x00\xeeIDAT(\x91m\x91AJ\x83a\x0cD\xdf\xa7UDT\xc4\x8dt\xe1\xc6\x0bx!o\
 303 \xd2[\xf5:\xd5]\x05W\x8a\xe2*3I\\\xf4\xff[\x15\x87!\xab\xbc\xcc@\x06\xbf\xf5\
 304 \xf1\xceE\x00TQ\xd7\xd4'uKq\xf0\x02X\xadV@UU\xd5\xd9yr\x95\xe0\xd1>\xc6G\x97\
 305 \xeaG\xb7\xd4vK_\xeb\xf5\x02\x80\xden_233\xab\x04\xd9\xad\xc9\xa9\xdeDG\xb44\
 306 \xee\xee\xa6\x84\xaa\xceLgZ\xea\xce\xee\xe8v\xb7\xba\xa3;:\xb4\x03\x90& 3\
 307 \xbd\x93|\xb8\xfd\x1f\xc0\x0e\xb0S\xd2\x0f \x0e@\xa9c\xaa\x84\xbdO\xb0\xedP\
 308 \xfc\x06\xe69'\x8c}%I\x11a[\x11\x7f\x13Z\xfb\xf3mo\xe7J\xd6\xac\xa9\xf7~\xfb\
 309 D\x1d\xd1\x16N2='x\xb9\\J\xb2s\x0c\x81\xc6\x10\x18\x84\xcc\xbd\xc9\xdc\xb9`\
 310 \xfc\xf9\xf4\xe6\x99X\xe0\xa2\xcc\xcd\x19\xf5\xc6\xeb\x03\x80\xe1\x14\x9e\
 311 \xe0\x1b\xafZe\xef\x08@\x1fr\x00\x00\x00\x00IEND\xaeB`\x82"
 312
 313 def getBEBitmap():
 314     return BitmapFromImage(getBEImage())
 315
 316 def getBEImage():
 317     stream = cStringIO.StringIO(getBEData())
 318     return ImageFromStream(stream)
 319
 320 index.append('BE')
 321 catalog['BE'] = ImageClass()
 322 catalog['BE'].getData = getBEData
 323 catalog['BE'].getImage = getBEImage
 324 catalog['BE'].getBitmap = getBEBitmap
 325
 326
 327 #----------------------------------------------------------------------
 328 def getBGData():
 329     return \
 330 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 331 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 332 \x00\x01\x07IDAT(\x91mN1NCQ\x0c\xf3\xfb\xbc.\x95\xd8X*\x15ua\xe1\x1e\x9c\xa9\
 333 #\x0b7\xe02\xcc\x95\x988\x02\xaa\x18:ua\x01\x15\x89\xd8q\x18~\x0b\x1f\x84\
 334 \x139\xb6\x9cHi\x87\xc3\x01\x13\xd8\x1ey*\xbe!\xbb\x03\x98\xcf\xe7\x00\xaaj\
 335 \xbc\xa9\x1a\xddiL\xb0\xdf\xef\xfbi\xa9\xa6\xa2\xfeCk\xcdv\xdf\xbem\x97\xc32\
 336 +\x7f\x12\x94\xcb\xa3\xf4\xa9\\\x9e\r\xfd\xf9\xe3\xb9\xe1\x0e\xeb\x9b\xf5\
 337 \xee}'K\x16M\x9aLF\x92\x19\x91A3\x144W\xe7\xab\xcd\xfd\xa6\x03P%\x8b*\xa9D3\
 338 \x1c4Y\x8c\x8a(\xd2\x11\x154U\x82\xd11 \x07iPT\xa8\x89\x8dDDc \x08\x06\x82\
 339 \x03\xa3\x82E\x0eDG\xc7#V\xd7\x9c\xbd\x86RR(\xc9\x0c\x89JR!\x91\x192%-/\xf4\
 340 \xb4A\xff|\xc0\xd9\xa5\xfcB\x90EV\x1c\x1f9\xf2(D(\xdbU\xde\x02\xdd\xc0@a\xb1\
 341 (\x12J\x88 \x1b\t\t#K\xc8\x1c\xdb@;\x00\x9e4~\xdb?\x11\x80/<\xd0e\x86\xc7\
 342 \xf1\xa9\x8f\x00\x00\x00\x00IEND\xaeB`\x82"
 343
 344 def getBGBitmap():
 345     return BitmapFromImage(getBGImage())
 346
 347 def getBGImage():
 348     stream = cStringIO.StringIO(getBGData())
 349     return ImageFromStream(stream)
 350
 351 index.append('BG')
 352 catalog['BG'] = ImageClass()
 353 catalog['BG'].getData = getBGData
 354 catalog['BG'].getImage = getBGImage
 355 catalog['BG'].getBitmap = getBGBitmap
 356
 357
 358 #----------------------------------------------------------------------
 359 def getBHData():
 360     return \
 361 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 362 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 363 \x00\x01"IDAT(\x91]\x91=n\xc2@\x10\x85\x9f\x91[\x174\xb1\x94\x88\x1b@\x93\
 364 \xdc\x86\x9b\xd0\x91\x94!H\xa4AJ\x8a\xe4\x0e4\xdc\x81\xa4\x83\x0b\xd0P\xd8\n\
 365 \x89L\x10\xce\xce\xec\xbc\x14\xeb\x1f\xc1\xd3h5+}\xda7\xb3/*\x8a\x02\xb5\x92\
 366 \xe5\xd2\x86Cx\x1f\xae\x06\x18\xa0u\x13**\x8a"I\x92@\xd0<\xf2\x1co\xef\xccrx\
 367 \xa5*T\xedt\xa2\x08U)\xf2\xbbX\xc4\x15J\x02\xc0z\x83\xd7\x17~\xed\xe1\x1cEB\
 368 \xd9\xf1H\xe7(\x12\xf5z\x06tZ\x1a\xc0`\xc0\xfb\x07\xa4i \xe8\x84\xce\xb5%b@l\
 369 f\xcd\x0e\\\xaf1y\xe2\xcfw\xf5\xbc\x13JKC\x04\xc1!\x98\x90d\xbf\xcf\xe7\x19o\
 370 \xaek\xc8\x9d9\xa8\x1a\x1074\x00~~\xe0q\xc2\xfd\x9e\xe2\xaayD\x1a\x87H\xc4\
 371 \x80\x8e\x99\xb1\x16n\xef8\x9b1\xbd\xe2\x9f\xbb\xa0\xa1JUmv\xa8\xf6^\xad8\
 372 \x9dr\xb7k\xe9p\xaa@}\xc8\'\xca\xb2\xac\xdb\xedV#y\x8f\xed\x96\xe31\x0f\x07\
 373 \xd4\x7foeI\xef\xe1=\xbc\xcf7\x9b\x98dY\x96\xc1\xc7\xe6s\x1b\x8dp\x1em\x93t\
 374 \xd0?w\xebTm\xac\xf7k\x18\x00\x00\x00\x00IEND\xaeB`\x82'
 375
 376 def getBHBitmap():
 377     return BitmapFromImage(getBHImage())
 378
 379 def getBHImage():
 380     stream = cStringIO.StringIO(getBHData())
 381     return ImageFromStream(stream)
 382
 383 index.append('BH')
 384 catalog['BH'] = ImageClass()
 385 catalog['BH'].getData = getBHData
 386 catalog['BH'].getImage = getBHImage
 387 catalog['BH'].getBitmap = getBHBitmap
 388
 389
 390 #----------------------------------------------------------------------
 391 def getBIData():
 392     return \
 393 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 394 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 395 \x00\x01\xffIDAT(\x915\xc9MH\x93q\x1c\x07\xf0\xef\xf3l\xc9|\x1e\xf7\xc2\xd6\
 396 \xdc\xcah\x8e,\x1b-j\xec\x90\x82t\x88^<F\xa7.\xa5DV\xa3K\xd1)\xe8\x9ab\x87\
 397 \x16Dt\xe9T\x92Ao \xd8I\x10)2!\x8a\xa4\xa9\x18\xb66R\xc2\xad={k\x9b\xff\xe7\
 398 \xf7\xff\xff:D\xb7\x0f|4\xced \x8c\x95\xbe\x1e\xb5%\x9d\xa1\x90"RD\x10B\xb5Z\
 399 \xc4\xac\x00\x05\xb4\x00\x00\xf1\xe9y\xe5\xacj\x07&\xa3_\xcf~\x07\xd0XX\xa8\
 400 \xcf\xcc8\x82AHI\xb5\x1a\x88\xe0r\xb1\x94v>o\x9e\x1a4O\x1cg\xe6\xf6\xd1v\x87\
 401 >P\xd1\xdc\x86\xbf#\x1c\xee\x8e\x9b\xc9\xfe\xf2\xab\xe7T,\x06\xce\r\xbb\xe2\
 402 \x07\xabo\xa6E.\x17\x1e\xbb\xbb-\xb67\xd3Z\xbd\xf5\xf1\xe6\xe2\xf4\xa2\xd3\
 403 \xef\xf1y\xda|\x0f\xbe\xa4\x13\x9d\xc9\xe1\xe8Px|\x9c\x99\x8b\xa5\xbc\xb0)\
 404 \x94N333\xdf[IOe\xa7\xfaB\xfd\xf0A\'\xa5\x00\x84:v,\x153\xa9\xf9+en2\xb3*XZ\
 405 \xf173\xd7Y\x9c\x99=\xfdv\xfd]\xb7/\xca\x1a\xa3\x05\xbd\xa1Z\x92\xa5bi\xb8LA\
 406 \xe2[e\x99k"\xd0\x13\x0f\xf6&\xb8\xda\\\xab\xadV\x9a5\xaf\xe9\xb5%\x91"(\xe8\
 407 \xbf\\\xa4X\x12S\xf9\x8f\xd5T\xcd=\xeeC?^<*e\x97\xac\x8d\xec\xda\xe3\xfbQ3&\
 408 \x9d\xa2P.\x90\xb2\xa5\x92\xe8\x80.\x95\xb4%\xe5\xac\\\x97\xbb\xeb\xc9\xc0\
 409 \x84\x87y\xf7\xf9\xcb\xbe\xc8~o8\x12M\xdd0\x98g\x8e\xcd\xf6\xfa\xf7\xad\x14\
 410 \x97m\x12Pp\xa2\x84\x8d\xfa\xfaH<u\xc4\x9bd\xc5?/\x8d@\xd3\xfc\xd7\xaf1k\x85\
 411 \xd1\xdb\xc2*E\x9e\xbd\x1e=<6\x17y\x9f\xfe|\x07\x9b\xd0\xf0\x10\xf6E\x9b\x99\
 412 \x1b\xf3\x1f\xac\xa7\x13\x8e\xc0vHiW*\xca\xb6u\xc3`\xa2\xad|\xce?t\xc1\x1c<\
 413 \t\xc0s\xd5\xa3\xcde\xe7v\x95;?%bU\xa0\r @\x01\x04\x08@\xfd\xf7\xbf::\xf9ri\
 414 \xe7\xe6_}h&tLr\xcb)\x00\x00\x00\x00IEND\xaeB`\x82'
 415
 416 def getBIBitmap():
 417     return BitmapFromImage(getBIImage())
 418
 419 def getBIImage():
 420     stream = cStringIO.StringIO(getBIData())
 421     return ImageFromStream(stream)
 422
 423 index.append('BI')
 424 catalog['BI'] = ImageClass()
 425 catalog['BI'].getData = getBIData
 426 catalog['BI'].getImage = getBIImage
 427 catalog['BI'].getBitmap = getBIBitmap
 428
 429
 430 #----------------------------------------------------------------------
 431 def getBLANKData():
 432     return \
 433 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
 434 \x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 435 \x00\x19IDAT(\x91cddbf\xa0\x040Q\xa4{\xd4\x80Q\x03\xa8e\x00\x0028\x00\x1c\
 436 \xbe#|\xfc\x00\x00\x00\x00IEND\xaeB`\x82'
 437
 438 def getBLANKBitmap():
 439     return BitmapFromImage(getBLANKImage())
 440
 441 def getBLANKImage():
 442     stream = cStringIO.StringIO(getBLANKData())
 443     return ImageFromStream(stream)
 444
 445 index.append('BLANK')
 446 catalog['BLANK'] = ImageClass()
 447 catalog['BLANK'].getData = getBLANKData
 448 catalog['BLANK'].getImage = getBLANKImage
 449 catalog['BLANK'].getBitmap = getBLANKBitmap
 450
 451
 452 #----------------------------------------------------------------------
 453 def getBNData():
 454     return \
 455 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 456 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 457 \x00\x01\xc3IDAT(\x91-\xcc1hSa\x14\xc5\xf1\xf3}\xef\xa5>\x93\x18\rv\x88\xc1\
 458 \xa1\x90\x08\x0e\x8aT\xc9\x92\x0e\xa2\x8b\xa0\x9b\x8b\xa0\xe0"\x1dD\x04\x89\
 459 \x14\xd4]h\'q\xe8\xe0((\xc1Yp\xb2\x9b\x8bh\xc1(\xa2Qi\x13)\tV\xdb\xe4\xbd4y/\
 460 \xdf\xbd\xb9\xd7!=\xd3o9\x7f3l\x02\x0e\xb0\x98N\x04\x90}\x08\x03\x02\x91}\
 461 \xb3@\x04FU\x01L\x06/\xc0\x7fEz\x90\x89\xaa\xc00\x0c\x0b3\xc0\x10V%QV\xe5\
 462 \xdd\xaf\xaf\xfci\xd8fo\x00\xb0\x80L\xb6%|:\xde\xdbvQt0\xef\x84\x08\x86DI\
 463 \xc5\x99\xd4qax\xe9 \xa8.,Lo\xaajL\xc6\x04\x176v\xce\xd2;\x97-\xb5`Td$L"\xce\
 464 \xdaC\xc3\xee\x0f\xef\xed\xdaZ\x1c\xc7\xf5z}\xb6Xt\xcc\xf9\\n\x12\xc7\xee\
 465 \xf9\x13\rw\xe9\xf4\xb3\x99\xc25?{\xd3f.j\xb2\x0e\x83~\xbbi\x00\xd4j\xf7\xdb\
 466 \xed\x1633\xf1J\xf5\xa4\xe7\xf9\xd1\xe5\xeb\xe5\xa3\xf9\xe8\xe5\xaa\xb8q\xa1\
 467 \xf6XUU\xd5X\x1b\xf6\xfbf\xf0\r\xe6\xc8\x83_?7\x1f.GLL\xe4\xaf\x9e/\xddy\xf3\
 468 >\xedh\xe5\xd2\x99\xde\xd5\xdb\xa9L\xe6\xd4\xdc\x9c\xaaZk{\xbd\x9e\t\xbf (.\
 469 \t\xb5L*\x19\x0f\xa8\xfb[\xc3\x7f\x98\xfdTB\xb2\xb7\xf4\xfa\xfb\xfa\xe8\x8fs\
 470 \x8e\x88\xce\xcd\xcf\xdfZ\\\xacT*&l\xe0\xc0\xb1{B-H\x02\x8f\x14.\t\x85bV\xe5\
 471 \xce&\xae\xdc\xed\x90s\xcc\xc4<)\x97\xcb\x8dF\xc3\x17\x86*\x1b\xaf \x9a(\xb3\
 472 \x82\x83\xc3dg&\x10:Q\xa5\xe6\xc7\xdc8\x92\xad\x0eou\xf9\xd1\xf2\x10\x80\xd9\
 473 \xf9\x00a\x88\x80\xdd>\x84a}8\x86\x8c\x00\x81M\x83\x03@ \x8c\x8d\xcf\xf8\x0f\
 474 f^,\xf4\xbdI\x03\r\x00\x00\x00\x00IEND\xaeB`\x82'
 475
 476 def getBNBitmap():
 477     return BitmapFromImage(getBNImage())
 478
 479 def getBNImage():
 480     stream = cStringIO.StringIO(getBNData())
 481     return ImageFromStream(stream)
 482
 483 index.append('BN')
 484 catalog['BN'] = ImageClass()
 485 catalog['BN'].getData = getBNData
 486 catalog['BN'].getImage = getBNImage
 487 catalog['BN'].getBitmap = getBNBitmap
 488
 489
 490 #----------------------------------------------------------------------
 491 def getBOData():
 492     return \
 493 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 494 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 495 \x00\x01\x1cIDAT(\x91mQ=\xaa\x14a\x10\xac\xd9\xfd4\xf2\x99\xa9\x0b\x06\x82\
 496 \xe01\xbc\x87\xb1\xb9x\t\x11C1\xf3\x0e&\x1e\xc2{\x18\x8b\x81,o\x1f\xe3W\x7f\
 497 \x063+\x066ES\xd5\xddtA\xf7\xd2GG\\#2&\x10`E\x8a\xe0?\x18\x00\xf0\xe1\x13\
 498 \x80\xa6K\x8c\xa4\x0e\xec%>\xda\x07\xb1r\xad\xca5o\xdf\x7f\x1c\x00P\xf4\xe7\
 499 \x0f\xd8H*ao\xbbb\xa5\x8a%+.\x8fO\x01\xc6\xdd+\xdf\x7f1\xf3dE\xd4\xb8v\xc3F\
 500 \xb0j\xd6\xac\x15\xb3\xe6\xe1\xe1\xdd\xf9\x19\xc6\xedk\xdc<]\xcdK+\xd4\x8dZ6\
 501 L\xff\x126l\xe6\xe1\xde\xcd\xafw\x18\x08\x1a\xb7j\x85\xb8e\xc2\xeeC\nf\xc3\
 502 \x86\x89\x0eQ\x82\x11\xa1`+\x84\xadru\xd8wo&a\xa3\xc2\x12\xc6\x17\xe1\xa5y\
 503 \xd1\xef\x84)\x13z#\xa5\xb3\xcbF\xae\x1e\x1c\xd7\xcf+\xc6\x9b3\xde\xf2\xf2}\
 504 \x9e\x19*b83Y\xeed+\x96\x8a\x9f\xe3\xf2\xed\x8c\x01A\xd1i\x9cT1r41\x15m\xd8N\
 505 \xeb\xd8\xb5a\x08\x0b\xbe\x02\x01\xf4\x0f69\xaf\xbf\xdd\x8a\xd8\xf3\x1f\xad#\
 506 |\xb7\xb6e\x1c\x8d\x00\x00\x00\x00IEND\xaeB`\x82'
 507
 508 def getBOBitmap():
 509     return BitmapFromImage(getBOImage())
 510
 511 def getBOImage():
 512     stream = cStringIO.StringIO(getBOData())
 513     return ImageFromStream(stream)
 514
 515 index.append('BO')
 516 catalog['BO'] = ImageClass()
 517 catalog['BO'].getData = getBOData
 518 catalog['BO'].getImage = getBOImage
 519 catalog['BO'].getBitmap = getBOBitmap
 520
 521
 522 #----------------------------------------------------------------------
 523 def getBRData():
 524     return \
 525 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 526 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 527 \x00\x01\xadIDAT(\x91M\x91;h\x93a\x14\x86\xdf\xfe\xf9B\xad(!\x83\x12\xdb\x82\
 528 C\x15\xc1[\x06G\x15\x94\n"\xe2\xe0%\xa0\xc4IQ!\x93C]\n\nE\xb1\xe0\xa2\xb4\
 529 \xde@\x1c\xc4\xcb\xd0\n*\xd6\xc1E\xcd\xa6.\xb68\x08\x0eR\x15\xbc\x10,M\x9b_\
 530 \xe2w\xdes\x8eC\x94\xe4\xe1px\xe1\xe5p\x86\xa7\x0b\xc7\xd1\xc6\x00\xfe\xdf\
 531 \x11\x88\x1d\xa15M\x04\x00#\xe5\x11\x07\xdc\xcd\xcc\xd4UM\xb7\xad\xff\x1d\
 532 \xc0\xa9w\t\x8djJ\x8a\x18Ee\xe2\xecD\x00\xe0\xf0o\x0b\xdf\xb5\xd5\x19\xef\
 533 \x1cL\xdd{\xdce\xb0\xf0k\xef\xddL\xa4P%j\xec\xcf\xf5\xff\xfb\xe0\xeej\xa4q\
 534 \xcf\xa6\xb4\xd4\xab\xc3\xc3c\xd3V\x10\xfa@\xf3\xc7\xd3\x8b\x87\x1e|\x95\xeb\
 535 \xd5\x0cU\x84\x82\x88\x04\x06\x1a5Io\xedOK\x03\x9c\xfeP:R)\xdc\x1c\xfaS)\xd5\
 536 g\xbaW\x9e\xb90txM\xac\x1e\xabG\x8a\x98\xa0\x89\x04Do\xaey{\x9f$.\x0e\xb9\
 537 \xfc|\xf0\xf4\r\xbf\xfa$\xcb\xb8\xe4\xfc\t\xcfo,\xbaG\xf7\xf8\xe6\xd4|\xb1\
 538 \xaf\x81\x14\t"f\xe7\x92\x93\xcf\xe8\x88\xeeqK\xfe\xad\xd0g>\xf9\xe8d\x98\
 539 \xafyq\xf9\xeb\xd6\xc1\xae{\xf1\xd5{A\x0e\t\x08\x92s\x0b\xc9\x81\xfba\xeas\
 540 \xac\x1c\x1d]\xbb\x98\xd6~\xba,z\xf5Qc\xf7\xf6s\x8fg\xe3\x86\xb1\xec\x97Z6\
 541 \xbb4\x8b:\x02"\xe8\x14\x15Q\x19\x7f\x99\xb9\xd4\x93\xbe\xb8\xb2\xc3\xa5\xcf\
 542 E\xbc\xfb\xe3\xe6\xf1 \x16\xa8B%\x8d\x00\x02"\x84,,[E\x151!W\x94\'\xa5\xbc\
 543 \xb5\x91\tv\xed\xe1\xba\xd5y\xaa)Uibj\x00\xba\xb0\xb3m\xb1\xd3h\xdb\xb4\xa2\
 544 \x93\xbf\xf2C/A9\xd1-\x1e\x00\x00\x00\x00IEND\xaeB`\x82'
 545
 546 def getBRBitmap():
 547     return BitmapFromImage(getBRImage())
 548
 549 def getBRImage():
 550     stream = cStringIO.StringIO(getBRData())
 551     return ImageFromStream(stream)
 552
 553 index.append('BR')
 554 catalog['BR'] = ImageClass()
 555 catalog['BR'].getData = getBRData
 556 catalog['BR'].getImage = getBRImage
 557 catalog['BR'].getBitmap = getBRBitmap
 558
 559
 560 #----------------------------------------------------------------------
 561 def getBTData():
 562     return \
 563 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 564 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 565 \x00\x01\x9eIDAT(\x91m\xca\xbfo\xccq\x1c\xc7\xf1\xe7\xf7{\x9f\xbb\xf6\xd2\
 566 \xf6\x82\xdc\xc5\x8f\x94F%\xc2\xc0\x1f\xe0\x0f`\xb2\x18\r\x06\t\xe9\x1f \x16\
 567 \x9300u\xa2\x0cX\xbb i\x84\xc9 \x06\x83\x10\x8b\x81\xa4\x069\x894\xbd\xeb]\
 568 \xaf\xe7\xbe\xfd|\xde\x9f\xf7\xcb b\xf1\xc8s|\x16\x93\xb7\x04\xc3\xf9\xcbq\
 569 \x07#4\xf0\x12\xaf\xf0\x88\x837\xf0\x80? \x04#\x1c\xbf\x01\x08G\x8eg\x91\xc1\
 570 \xd4XT\xb4\x10?\xab\xb0L*\xa2\xe9U\xday\xba\x16<\x00R\xfc\x812\x9e\xa5\x04Y\
 571 \xcd\x13\xbeo\xa9\xaa\x14\xabq\xd9\xbb6\xea\xc6\xce\xea\x97\xda\xb1\xc3^\xa7\
 572 \x04\x84\xfe\xdd\x9e\x15\xa2\xb6?\x0e\x06\xa3\x98r\xddc\xd1^\xdeZ\xfbY\xec\
 573 \x89\x9aJ\x9e(q\xf0\x8c\x9b\x94\x90\xa9\x8c\xbfF\xe5\xc6\xe4\x90\x0f_\x0f\
 574 \xc7\xf1\xfd\xf3\x95\xef\x9b[\x9d\xcb\xb7\xb4\x13\x95\x13\x10pP\x96\x92d\x14\
 575 \xa6*ugV\x89\x93Z]\xa1\xa6S\xe7\xafB9\xf7\xe8\x92\x9a\x89d\x0e\xc1\r\xc9\xe4\
 576 \xa6"R\xb3\xde\xde\xeb>\xa9\xf67\x06\xb9J\xfdIs.m\xd8\xcb\x9b\x1aD\xcd\xa4"\
 577 \'\x87\xd2\x1dyR-Nf/\xac\x87\xbb\xfd\xcdv3o\xa7^\xb7u\xef\xe2\xc2\x87g\xe3\
 578 \xb9\xf9\xfe\xd9;\x1a%\xcc\x94\xcd\xa0\xf4\x085\xd3\xf4\xc9\xfe\xf0\xf4\xf4\
 579 \xb7\xed\xc5\x87W\x8a\xe9\xe6\xf0\xcdc\xb1\xabO+\xed\xdbg\x8e\xdc?\xa7v\x94%\
 580 y\x06B9\x8bJ\xd3\xbb\xde\xc1\xf5e\xa6\xb2\x8e\xce\xb7\xbe\xbe\xa87bq`\x812\
 581 \xd12\xdcP&g<;\x14\xa3\'\xb0\x84\xef\xe2\x1d<\x82\xe1c\x9c\xff\xf4\xc7o\x85!\
 582 #\xea\x19>\xf5\x97\x00\x00\x00\x00IEND\xaeB`\x82'
 583
 584 def getBTBitmap():
 585     return BitmapFromImage(getBTImage())
 586
 587 def getBTImage():
 588     stream = cStringIO.StringIO(getBTData())
 589     return ImageFromStream(stream)
 590
 591 index.append('BT')
 592 catalog['BT'] = ImageClass()
 593 catalog['BT'].getData = getBTData
 594 catalog['BT'].getImage = getBTImage
 595 catalog['BT'].getBitmap = getBTBitmap
 596
 597
 598 #----------------------------------------------------------------------
 599 def getBWData():
 600     return \
 601 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 602 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 603 \x00\x01\x0eIDAT(\x91}Q\xb1J\xa3a\x10\x9c\x8d?\x8a`\x08\x9c\xa0\x9d\x81\x03\
 604 \xf1\r\xf3\x04b\xe9\x8b\xdc\x03\xd8\xd8\xa4S\x1f!M X\x1d\x17\xb8\x80B\xd8\
 605 \x9do\xc6\xe23!w\x88S\xcc.\xec\xee\xb0\xcc\xc4\xf5\xb3\xff\x12\x1d\x94R\xa0\
 606 \x90\x82%H\xa0@a\xdf\x03\xc3\x9f\xc4\xddO\x18\x10lG\x13\x04\xd0\x96\x82>j\
 607 \x1e5\x9br\xc9\xcd\xbe\x7fz\x1bF\x80\x8c\xdf\xe5fH\xa0\xdd\x0c\xca\xb4;\x97\
 608 \\2\xe5\xcb\x93\x00\x15\x9b\xcdf<\x1e\xf7\x97lw\xfe\x12\x11\xb1\\.\x03\xc0l6\
 609 [\xadV$Y,VGfUe\xeeJUM\xa7\xd3\xf9|>\x00 [U\xed\x0f\xfa\xf8\x9f\xf5\xcc\xbe\
 610 \x00`\x00\xd0\x1aIf\xe5N?3\xebP{/\x01 \xd6\xeb\xf5d2\xf9\xfe\xfb>\x8d\x88\
 611 \xc5b1\x9c\xbf\x9c\xdd\xde\xe0u\xeb\x12\x0e=\xe9L\xb9\xba]\xc2\xd5)~=\xfe\
 612 \x18@\xc9\xa3\x8b\xe3n%\x9aA\xa1\x14\xbdiB3\x9a\xa3\xc9\x02@\x05\x1e\xde\xb1\
 613 =\x08\x95\xf8\x8c6\xff\xcbX p\x8c\x0fgu}a\xae\xcd\x92\xb9\x00\x00\x00\x00IEN\
 614 D\xaeB`\x82'
 615
 616 def getBWBitmap():
 617     return BitmapFromImage(getBWImage())
 618
 619 def getBWImage():
 620     stream = cStringIO.StringIO(getBWData())
 621     return ImageFromStream(stream)
 622
 623 index.append('BW')
 624 catalog['BW'] = ImageClass()
 625 catalog['BW'].getData = getBWData
 626 catalog['BW'].getImage = getBWImage
 627 catalog['BW'].getBitmap = getBWBitmap
 628
 629
 630 #----------------------------------------------------------------------
 631 def getBYData():
 632     return \
 633 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 634 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 635 \x00\x01LIDAT(\x91M\x8e\xb1jTa\x10\x85\xbf\xbd{\xb1\xddj\t[\xa4\xf1\x1d\xf2\
 636 \x12\x16\xe2\x0b\x84`\xaa4a\x1b+\xb1\xd3\xd8\xa4\x8b\x16>E0A\x10RX\xda\xf8\
 637 \x10\x11,D\x16\x91\xbdw\xaf\xee\x9d3\xf3\x8f\xc5\xbd\xc9f8\x1c\x0e\xcc|\xc3!\
 638 \xbb.\x8f\x8e\xf2\xf66!\x1eH\xd0\xc3?\xe8\xa0\x855\xfc\x81\xdf0I\xa0\xef9;K\
 639 \x89R\x88H\x0f\xc2\xd3\x1d\xf7\x94\xf2\x81o\xae\xafk\xd6knnr\xb9d\xb9$"\xa5\
 640 \xc1G\x99R\x96f)M\xf6\xf7\x0b\xd4\xccf\xb9\xd9pz\xba\xbb6K\xf7\xf1T\x96\xa6\
 641 \x01@*P\x95\xd5\x8a\xab+\xce\xcfSB>\xec\xd2lTo\xbb,\x015\xf39]\x97\xc7\xc7#\
 642 \xe0\xe3\xbf\x11\xbb\x87%\xdc\x0bT\xacVyy\x99\x17\xef\xee\n\xdcy\xdf\xef\xdc\
 643 ,\xcd\x86Juy\xf2,\xbf|\xeeN\x9e\x1f\x9e\xb8\x8aYHa\nY\x91\x8a)da\x1eR\xf1\
 644 \xc73\xff\xfa\x96\xaa|\xfaX\xde\xbc\xde~x\xdfN\xad\x9d\xaa\x9dZ3\xaao*[W\xd6\
 645 L\xad\xa9\xad\xad\xd5U\xc1#\xea\xb27g\xd3T\xaf^,\x9e.\xbc\x84\x87T\xa4"/\xae\
 646 \x90\x17\xf7\xf4\x88\x88\x8c\xc8`\xcb\xa4\xfb\xf9\xeb\xefb\xef\xfb\x8fo\x07/\
 647 \x0f00pv\x010\xd8Ba\x98\xffo7u\x96\x0c\xc3,\x8e\x00\x00\x00\x00IEND\xaeB`\
 648 \x82'
 649
 650 def getBYBitmap():
 651     return BitmapFromImage(getBYImage())
 652
 653 def getBYImage():
 654     stream = cStringIO.StringIO(getBYData())
 655     return ImageFromStream(stream)
 656
 657 index.append('BY')
 658 catalog['BY'] = ImageClass()
 659 catalog['BY'].getData = getBYData
 660 catalog['BY'].getImage = getBYImage
 661 catalog['BY'].getBitmap = getBYBitmap
 662
 663
 664 #----------------------------------------------------------------------
 665 def getBZData():
 666     return \
 667 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 668 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 669 \x00\x01\xa4IDAT(\x91U\x91\xbfk\x93a\x14\x85\xcf\xfb\xf5k\x92j\xdaDM$BB\xb1\
 670 \xa5:(\x82\x14\\\xfcA'Aqtprr\xf6_pp\x11\x04\xf1?p\x13\xc7\xee\x82P\xed(\x05+\
 671 :\xd9\x82\xb6\xd6\xd8\xb4I\x93&\xe9\x97\xf7\x9e{\xafC(\xd4\x873\x1dx\xa6'\
 672 \x8c\xf0\x1f\x04\x08d\x00\x80\xdc\xf1i\xc7\x03\x100\xbb\xf1\xe2\xd9Y\x00\x06\
 673 7\xc5(_\xc8\x0f\x86\xa7\x0bQ\x8c\x9d\xded\x7fb*\xb4\xbbT\x08\x9d\xb47/\xbf\
 674 \xa6\xa8\xd4\xb2S\xb9\x9d\xb6\xab:\r\t\xb1t\xa7u\xbe\x9ee\xaa[\xcd\xf8~\xf9J\
 675 \xb7[\x12\xba\xd0\xeb\xd5\x04\xb8\x94\x00p\x03\xd5\xc5\x90\x04}\xf4x\xf5\xee\
 676 \xe5\xe9\xc5\xa4q\xc3j\x0f\x1a\x95'OWr\x93\xa3H\x8dT\xa1\x021\x01As*\x94>w\
 677 \xa1Y\xcf\x97\x8b\xdd\xb0\xfe\xfd\xd3\xda\x97\x8f\xfekT\x0b\xc5\xab\xd76\xa3\
 678 \x84(&t\xc0\x12\xd0\xd4\\\xd5\xa9\xa8_l\x96\xfdL\xaeX\xc9\xb6\xe9[\xcd\xda\
 679 \xec\\\x19\xd5\xda\xfc\x1fQ\x8bt\xd1\xb1\x10M\x15\xa2\x1e\xd5\x9a\xdb\xe5C?8\
 680 \xca\x8ez\xf9\xeaO,\xec\xf5\xf6G\x18\xb4\x7fOKt\x11'\r\xb0\x14\x11\xa2.tQ\
 681 \xff\xfc\xad\xbexo\x95Yz\xfb\xfa|T\xdb\xe8\xfc8\x9ci\xad|\xb8\x19\xa9\x91FK\
 682 \x00K\x91\x81\nQDb\xc0\xe4\xf5\xab[\xf7\x1f\xae\xcd\xe4;$\x0e\x10\xde=_\xda\
 683 \xd9\x87\xd0h\x89j\x00\x90bw7\x0c\xcf5\xa6\x9c\x84\xd0\xe3D\xba\xfev\xa1T\
 684 \xea\xab\xe2\xef^\xae\xec^\x9a\xe9\xab\xb9\xa9\xb3\xef\xc0fh\x9d\x089\xce<\
 685 \x04\xfa\x00\x81\x02P8Qz\xcc?(t\x190\xef\xfd\n\xa2\x00\x00\x00\x00IEND\xaeB`\
 686 \x82"
 687
 688 def getBZBitmap():
 689     return BitmapFromImage(getBZImage())
 690
 691 def getBZImage():
 692     stream = cStringIO.StringIO(getBZData())
 693     return ImageFromStream(stream)
 694
 695 index.append('BZ')
 696 catalog['BZ'] = ImageClass()
 697 catalog['BZ'].getData = getBZData
 698 catalog['BZ'].getImage = getBZImage
 699 catalog['BZ'].getBitmap = getBZBitmap
 700
 701
 702 #----------------------------------------------------------------------
 703 def getCAData():
 704     return \
 705 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 706 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 707 \x00\x01\xa1IDAT(\x91M\x91\xbdn\x13A\x18E\xef\xcc\xcez\xd7?`\xcb\x0e\x16\xa2\
 708 A@\x01\x0f@H\x9d\x9a\x927H\x99\x0e\t\xc9\x12U^\x80\x86\x82\x9f\x12Q\xe7\x05\
 709 \x10o`\x94\xca\x12E\n"\x13RD$\xca\x92\x85\x9d\x99o\xe6\xbb\x14\x96\x10\xa7\
 710 \xba\xc5)\xaetL\xf3\xf4\x99^]Yg\xfd\xf9\xe9p\xb9\xc4\x7f\x90\x04\x10c<\x9b\
 711 \xcdz@\x04\x12\xe0t}\xda_<\x07P\\_\x0e\x06\x03\x92$c\xd3\x18E1\xb9I\xd5\xd2\
 712 \x95\xb7\xf6\xf7]5\xd2\x9c\xbf\xbd~\xe50\xaa\x01\xea\xcf\x8b|y\xbe\xb1\x93\
 713 \xb2}\xf3V}\x1e\xbe|Q\x18C2\x1e\x1fk\x7fb\xef\xdc\x8e\x80CRf\xa5$\xa4D2\xac\
 714 \xbe\x06\x8d\xc5\xc9\x1a\xd1\xff^~q9WO\xb6\xd1u\xd9\xd4\x0c1\x01NcD\xce\x14a\
 715 \x08$\xdbw\xef\xddh`\x86c\x96u\xfe\xf0\xf1\xfa\xfb\xc9\xfc\xf0P\xbb\x00\xd3\
 716 \x99\x18\x12\xe0\xe0\xbdJR\x11\x8dB\x12\x0f\xee\xf2\xe8\x88\xe5\xc8\xb4\xde6\
 717 g\xc5\xc3G\xaa\x9aBg]_\xa3D\xc0&\xef\x99\x84"\x1a<\xc9\xd1\xde\xde\x9f\xd9Vl\
 718 \x1a\x91\xb6\x9d\xce\xc7\x8b\x05I\xf1\x9e!\xe6\xb8\xb9\xd4\xb6\x14\xd1\x104\
 719 \x04UE]\x8f\x0f\x0e\xba\xcf\x9fLUOwvL]\xe7\x9c\x19B.#D\x12\xe0\xd2\xc5\x0f\
 720 \x8a0D\xf5^UI\x9a^\x89\xed\xc7\xb6W\xa3\xaar\xce\xaa\xaa\xbe\xd3^\xb0)E\xc0%\
 721 @\x83\x98\xe9\xc4\xe6\xce\x18\xb3\x89UM\xb7\x0c\xa9\x80\xb5\xd6\x18S\xde\xbb\
 722 _L\xe6*I\x01s\x0c(\x90\x80_\xc0\x8d\xd5\xca{\xff/\xf0f\x88\xc8zw\xb7\x07(\
 723 \x00\xe0/\x16\xb12\xdd\xfc\xf2\xe0\xa8\x00\x00\x00\x00IEND\xaeB`\x82'
 724
 725 def getCABitmap():
 726     return BitmapFromImage(getCAImage())
 727
 728 def getCAImage():
 729     stream = cStringIO.StringIO(getCAData())
 730     return ImageFromStream(stream)
 731
 732 index.append('CA')
 733 catalog['CA'] = ImageClass()
 734 catalog['CA'].getData = getCAData
 735 catalog['CA'].getImage = getCAImage
 736 catalog['CA'].getBitmap = getCABitmap
 737
 738
 739 #----------------------------------------------------------------------
 740 def getCBData():
 741     return \
 742 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 743 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 744 \x00\x01NIDAT(\x91U\x91/o\xd3q\x1c\x84\xaf\xcd\x8f\xfdIZ\xc9\xc2\xb2t \x088\
 745 \x82!$\x08\xc8\xf4\x02\x82\xf4\x05\xccL\xf1\x0e\x86\xc1\xf1*\xd6\xbd\x04\x12\
 746 4z\x1eO\x05t\xa2\xc8-!t\x9f\xbb\xef\x1d\xa2\xbf\x060\x97G\\\xee\xc43\xc0\xf1\
 747 1\xce\xce\xb0\xb5\x85\xd5\n\x00lH\x00 \xf5l\xf7 a8\x1c\x00x?\x9b\xe1\xe8\xc8\
 748 \xbb\xbb&["\xa0\xd9Jd\x0b\xa0-\x9b\t\x93\xcf\x97\x97\x1d\x00\xcc\xbf]\xcd\
 749 \xe7m:mw\xefq\xc5\x96\xd0`\x9f.\xa7\x1c\xda\x93\xed;\xf0\xa8\x03`\xa7-~\xe8\
 750 \xfc\xfc\xdd\xcb\xe5\x8b\xa7-\xaeD1\xe3Jj\x03\x1c\xf8\xf0z\xf5\xa5\x03\xd0Z\
 751 \x93\xa4\xe5\xf2\xe2\x93\x06\xe0\xf3\'L\xd8\xf7\\\xc9\x1a\x88\x10\xc0\x10\
 752 \x80\xd4H\x92\xfcy\xcd\x8f3~\xbf\xaa\x0c\xabo\x9bi\x1bn\xb2\xb0~\x90\xa4b\
 753 \x8d\x86:\x9dr\xb2_\xa9~\xf5\xdf\x87\x81ia\x08\x80dUi4>}[\xaf\x9eUTi\x9b\xf6\
 754 &a%\xd2\n\x1d\x00I\xdc\xdb\xe3\xc9\xc9\x87\xc9\x83\xfaUe\xd3\xf9\x9b\xb1l9\
 755 \x0f\xb3\xfd\xb5\xbb\xec\x00\xf0\xf0\xfe\xfe\x9b\xd7\x1c\x8fu{\xab\xad\xd0\
 756 \xa6\xad\x84\x1b\x1b-iv\xcbo\xd4\xb2\xc3\xc1\xc1\xc5\xe3GX,ps\xd3\xeb\\{\xad\
 757 \xfa\xcf\xf1\xda\xfd\xce\xce\x1f^/x\xe8m\x93\xb4\xa7\x00\x00\x00\x00IEND\xae\
 758 B`\x82'
 759
 760 def getCBBitmap():
 761     return BitmapFromImage(getCBImage())
 762
 763 def getCBImage():
 764     stream = cStringIO.StringIO(getCBData())
 765     return ImageFromStream(stream)
 766
 767 index.append('CB')
 768 catalog['CB'] = ImageClass()
 769 catalog['CB'].getData = getCBData
 770 catalog['CB'].getImage = getCBImage
 771 catalog['CB'].getBitmap = getCBBitmap
 772
 773
 774 #----------------------------------------------------------------------
 775 def getCDData():
 776     return \
 777 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 778 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 779 \x00\x01\xa1IDAT(\x91M\x91=h\xd3\x01\x10\xc5/1(6\x16m\xd1\xc6\x14\xfe\n\x82\
 780 \x1f\x84\xe2G\x89\xc1\xe2\xc7\xe4dgg\x1d\\u\x14\x04\x17\x97\x0e\x82\x85\xe2\
 781 \xe0 \xa2\x83\x93\x9bUG\x87\xa2h\rQJ!v(\x19\x92\x1am\xd5\x06A\xd4\xe6\xee\
 782 \xbd\xf7wH*\x8e\xc7\xdd\xe3\xbdw\xbfLrq\xb2u\xfd\xc5\xbe\xdb\x93+\x8b\x15\
 783 \x93\xcce\x809\xcce\xee\xb6\x01K\xdd\xcc\xcd`\xe6f\x9e\xb1\xc3\xb7\x1e\xcd\
 784 \x8c7\xd6\x0bHS1\xa5RH\xa4\xa0\x14\x10\xa8 \x01\x05\x15\xe4\xec\xcd\xbb\xb9\
 785 \xe4h\xf5\xd2\xf1\xee\x9d\xb9\xd2B{\x94RH\x04\x03iH\x01\x06\xe8\xa0C\x01&\
 786 \xbb\xf3f\x9e]Y,?\xfc0\xb1\xd0\x1e\x85\x14\x14AG\x1ad1\xff\xd5\xfb\xd7\xf4\
 787 \x80\x07\x022\xf3l\xa1T\xbd|\xe2Ui\xa4\x05\x12\xa4Ci\xea\x13\xc9\xd2\xd4\xf9\
 788 '\xc9\x8e\xd5n\xd0\xa3/\x0b\xca\xcc\xb3k\xb5\xf1\xfb\xb5S\xef\xdb\xc5\xa0\
 789 \x02\n\xe8\xdc\xfe\xfa\x8d\xb3O\x87\xb7w\xa6/<.\x0c|\xeb\x0bB\x00\xcd<\x9b\
 790 \x1f{}e|nl\xa4\xf9/\xc0\xb3\x8fG>\xfd\x18H\xd5}\xbet\xa8\xb1\xbe\xd3\xd17\t\
 791 \xc8\x0c\xb9_\xf3\xe5{\xef*\xd5V\x1eT\xf4wzP+\xcf7\x93\x03C\xed^\xe9\x00\x01\
 792 Q2\xf3-v\xd2g\xafn\xd4\xbflmv\x067\x7f\xc2\xfa\xea\x9e\xce\xef\xdc\xf2\xf7!\
 793 \x0f\x06\x08\n\xd4\xae\xfc\xb6\xb5\xea\xcb\x9c\xbd\xa9\xcc\xbc=\xfd\xf9\xcf\
 794 \xde\xe20A\x01\x0c(\xd8# \x90`J\x8a\xea9(c\xc7\x0e\xfe\x9cZ\x1e\xbcV\xb0\xc6\
 795 \x99\x1e\xcbM\xae\xf8o\x94\x19\xccdf\x7f\x01\x1d\x0fu\xc7m\x02\x91\xc5\x00\
 796 \x00\x00\x00IEND\xaeB`\x82"
 797
 798 def getCDBitmap():
 799     return BitmapFromImage(getCDImage())
 800
 801 def getCDImage():
 802     stream = cStringIO.StringIO(getCDData())
 803     return ImageFromStream(stream)
 804
 805 index.append('CD')
 806 catalog['CD'] = ImageClass()
 807 catalog['CD'].getData = getCDData
 808 catalog['CD'].getImage = getCDImage
 809 catalog['CD'].getBitmap = getCDBitmap
 810
 811
 812 #----------------------------------------------------------------------
 813 def getCFData():
 814     return \
 815 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 816 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 817 \x00\x01\x8fIDAT(\x91M\xca?HU\x01\x18\x86\xf1\xf7\xdcs\xecv+\xba\x9e\xc1\xe2\
 818 *\ri\xd2\x14Ak5\xd4\xeaP\xad\xd5\xe4\xe0\xd0?\x97\xbb:D\x93--\xe1\xe4\xec\
 819 \xe0\x92\x10\\]\xb3%\x08\xbaM!\x14(hD\x9bqO\x83\xdf\xf7\xbd\xdf\xdb`A\xbf\
 820 \xed\x81\xa7\xe8\\\xdd)\xbb\xf5\x9b\xa5\xde\x9d\xe7?\xd0\x82g\xb2\xc1\xaf\
 821 \xcf=\x02\xe3\x97\xf61\x96\x08\xc2\x12$,aQ\x95\xdd\xf1\x9d\xb5\x8d\xa9\xa9\
 822 \xa5\xfdkk\xeb\x1f\x1e3\xa1#\x9cz\xf7T\x11/oLx)RLy\x88\xca\xe5g\xdf\xaa$\xb6\
 823 \x86\xf3\xf7:/^\xbf}\x94\x85\xd2\x91\x94vw\xe5\xfe\xfdr\x06\xe5\xa1`z\xe8|]\
 824 \xa0Aqp\xf0srr\x82\x04\x80\xa2\x10\x00@\x9a\x9b\x93\xb9\xb66\xf5O\xa6\x8a\
 825 \xa2\x18\x0e?U\x80\x03(KH\x82 H\x92\xccd\xae\xff\x00\x020\x1a\x8d\xaa\x85\
 826 \xf7\x0b\x8b\xd7\x17\x0f\x8f\x0e)2\xc9V2\xe3\xa1\x99\xdcW\xbf\xaeF2\x8d\x14#\
 827 \xa3n\xd7\xfdA\xbf\x1al\x0ef/\xce\xee5{\x96\x16\x0cOw\xda\x03s\x99\xad|\\1\
 828 \x9a\xd3-\xcd\xe9\xd3\xdd\xe9f\xa3\xa9\x10p\xb9\xd1"\xc3i\x96n4\x99\xcb\xfd\
 829 \xefM\xf3\xca\x03\xc12p\x02U\x7f\x1e\xf7g\xe2\xb7{\xca3\x9d\xb0\x94\xc9\\f\
 830 \xafn9\xd3\x93\x96\xf2\x14\xcf\x8cq\xf9\t\xaa\xbb\'q\xa5\x0e\xa9\'9@\xc9%\
 831 \xc7\x05G\xc4\xed\x9eK!\x85D\x80\x00\xcf\xddD\xb1\xbd\x8dV\x0b\x9d\x0e\xdam\
 832 \x9c>\x0b\x10\x99\xe0\x0c\x12\xc8/\xe0q\x12\x998\xf6\x07\x92\xb1\\\xa0\xd2\
 833 \x03\xbd\x9e\x00\x00\x00\x00IEND\xaeB`\x82'
 834
 835 def getCFBitmap():
 836     return BitmapFromImage(getCFImage())
 837
 838 def getCFImage():
 839     stream = cStringIO.StringIO(getCFData())
 840     return ImageFromStream(stream)
 841
 842 index.append('CF')
 843 catalog['CF'] = ImageClass()
 844 catalog['CF'].getData = getCFData
 845 catalog['CF'].getImage = getCFImage
 846 catalog['CF'].getBitmap = getCFBitmap
 847
 848
 849 #----------------------------------------------------------------------
 850 def getCHData():
 851     return \
 852 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
 853 \x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
 854 \x00\xb0IDAT(\x91\x85R\xc1\x15\x830\x08\xfdQ\x0f\xbeN`:\x86kd\x8c\x8c\xe1,\
 855 \x1e=zt''h\xfeE\xed!MM\nV.\x10\xe0\xc3\x87`LU\x03\x00\xf6};\xf0G\x98\xd9\x8f\
 856 \xaa6\xc9n\x8a\xacaP\x90\x04H\xb4\x1f\x9b\xe3X\x84\x1b\x01XW \x04`\x9aN\x9fs\
 857 Q[[0\x01\x80J\x14\x08A\x9b\x00$\xd5\x98d\x90wN\xc0y\x8e\x0f\xefE\xbad\xf0\
 858 \x0b\xbe\x91\xb2@\x06\xd0\xc0$\xc5\x0e\xbe#\x10@K\x02\xceE\xf0\xb2\x9cY}\x1f\
 859 \xb5\xb5\xf7\x0c.i_\xf8\xc5\x12\xdb\xae\x8b\x86\xf7g\xb1\xd4Y\xf9\x05\x93.\
 860 \xf1\xb5o\x87\xd6C\xf3=\xb3K|\x03.\x95H\xe5<\x9c\x19h\x00\x00\x00\x00IEND\
 861 \xaeB`\x82"
 862
 863 def getCHBitmap():
 864     return BitmapFromImage(getCHImage())
 865
 866 def getCHImage():
 867     stream = cStringIO.StringIO(getCHData())
 868     return ImageFromStream(stream)
 869
 870 index.append('CH')
 871 catalog['CH'] = ImageClass()
 872 catalog['CH'].getData = getCHData
 873 catalog['CH'].getImage = getCHImage
 874 catalog['CH'].getBitmap = getCHBitmap
 875
 876
 877 #----------------------------------------------------------------------
 878 def getCLData():
 879     return \
 880 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 881 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 882 \x00\x01\x0bIDAT(\x91u\x8c=JCQ\x10\x85\xbf{\xdf\x13\x13\x8b j\x93\xd2\xacAD\
 883 \\\x8a\x856\x82e\x16`\xe5NR\xb9\x07\x1b[!6\xb6\x82H\x10\xecb~$\x9a\xe4\xce\
 884 \xdc\x19\x8b\x04\xc93\xe6p80\x9c\xefL\xe0\xea\x81oE!\xc2\xcc\xd8\x89\xb9s\n\
 885 \xd8\xbf\x82\x92\x89^\x9f\x1d^\x1c\xefw\x1e\x07Yr\xa3^@\x00\x0f!\x14E\x11c\
 886 \xf4\x15M&\x93\x88qyr\x80s~\xb4\xf7\xf61\x7f\x1f\xcdaY\xaf}\xc7\xcc"p\xfb4\
 887 \xc8\xeew\xcf#Q\xd7\x8co\x96\x99\x95\xd4v\xc7\xbaus?TG\xb7k\x9a\xd3&\x1a\x00\
 888 J^_\xe2g\xbd\x18\xcf,{4K\x8d\xbaO\xa7\x0e\xabo\x97\x83\x18\xad\xdf\x0f\x19h\
 889 \xb7\xbd\xd7sI\x88\xba\x88K\xf2$\x9e\x92K%c\xab5\xecvK\x83 \xe2)\xa1Z\x81\
 890 \xaa4\xaa\xae\xaaP\x1a\x14\xaa.\xc2/\xb4>SA39\xb3\x18DQ\x9aM\x17A3*\x88\x04\
 891 \x11TY\xa4*9/l\x10\xbe\xc0VL\xf5\xfcS\x01?\x86\x8dh\x06\xba\xfb\xef\xab\x00\
 892 \x00\x00\x00IEND\xaeB`\x82'
 893
 894 def getCLBitmap():
 895     return BitmapFromImage(getCLImage())
 896
 897 def getCLImage():
 898     stream = cStringIO.StringIO(getCLData())
 899     return ImageFromStream(stream)
 900
 901 index.append('CL')
 902 catalog['CL'] = ImageClass()
 903 catalog['CL'].getData = getCLData
 904 catalog['CL'].getImage = getCLImage
 905 catalog['CL'].getBitmap = getCLBitmap
 906
 907
 908 #----------------------------------------------------------------------
 909 def getCNData():
 910     return \
 911 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 912 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 913 \x00\x01$IDAT(\x91]\x911JCa\x10\x84'\xc9\x8bb\x11\xb0\x12S\xa4\x10\x04/\xa0G\
 914 \xf0\x18\xe6\x10\x96Zx\x1d\x0b\x91\x98\xc2\xc6RA\xbc\x80\x9e\xc0BE\x10\x13\
 915 \x13\xb33\xbbk\xf1\xbf\x17\x1e\xc2\x16\xc3\xb23\xfb\xb1\xdby\x01\x02\x08\xa0\
 916 \x0b\x00\xd8>\xc6\xfb\x1d\xd04\x05\x00PKW\x01\xec^\x9c\x0fN0\xbb\x8c\xfe^l\
 917 \x1e\xf9\xf6\xab\xcf&\x82)\xa5$CJ\xb2\xe8\xe7\xe9\xb4\n`0\xce\xde\xce\xeb`\
 918 \xec\x9fg\x1e\x0bn\x1cz\xff\x80\xf3\x1b&\x99\xc6\xa4\x85Y\x92\xd5h\xa4\x022\
 919 \xbf\xca\x98\xf9\xcf\xad\xfb/;\x03O\x99\xbf1\x8da\x96\\\x85Y]\xa4\x80\n@|\
 920 \xf9\xc7\xa9\x90\xda:R\xb5\xcf\xe5\x03\x97\xf7\x8cVv\x9a\x05\x99\xc5\x10@\
 921 \xac\xbc\xb0.\x9f\x84-\xce&\x96d\x92%\x15M|H\xb5!])\x81\xe6\x0b}_3i\x85'\xd6\
 922 \xd9\xc5@Fm(-)[\x00\xff\xa7%\xac7@*\x88A\x86Y=\xd1p\xa7Y\x88)Ow\x00\x95\x80\
 923 \xa0z\xc3a\x92]y\x8au|s\xfe\x90\xe0\x1e\xee\xe9.\xa0\xf3\xd8zd[\xa8\xf5\xech\
 924 \xaa\x02\xfe\x00:\xaes0^l*\xa0\x00\x00\x00\x00IEND\xaeB`\x82"
 925
 926 def getCNBitmap():
 927     return BitmapFromImage(getCNImage())
 928
 929 def getCNImage():
 930     stream = cStringIO.StringIO(getCNData())
 931     return ImageFromStream(stream)
 932
 933 index.append('CN')
 934 catalog['CN'] = ImageClass()
 935 catalog['CN'].getData = getCNData
 936 catalog['CN'].getImage = getCNImage
 937 catalog['CN'].getBitmap = getCNBitmap
 938
 939
 940 #----------------------------------------------------------------------
 941 def getCOData():
 942     return \
 943 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 944 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 945 \x00\x01\x11IDAT(\x91e\x8e\xb1\xae\x8ea\x10\x84\x9f\x8f/G\xa3!"\x14\x12r.@\
 946 \xed\x9e\xb4*7\xa0v)"\xd1k\x84FI\xe3\x88B\xa1R\xfa\xed\xcc;\xa3\xf8\xcf\x9f\
 947 \x1cl&\x93\'\xbb;\x9b\xdd~\xbe!\xe1\xb2BBr\x02\xff\'\xd8\x13n?~\x0e\x94\xd0\
 948 \xd0U\x16qk\xe2\xa2\xc6\x8dZ\xb7\xbax\xfdj\x07\xa0\xd5w\xba\xc8jEW\xa3V\'\
 949 \x9ff\x1am7\x1e\xc4\xec@\xe9\xdf\xdb\xd3\xbaQ3\xed\x9c@D\x1ev\x0c,p7\x83\x8b\
 950 \xba\xa9UQ\xb7i\xa7\xa8L+\x10a\xe3\xd6\xbbg/\x1e~\xfb1^\x95#W\xbe\x84Q\xe4\
 951 \xcc\x91\xbd\x1e\xdd\xbb\xf1\xf6\xe5\xfb\x9d\x036v\xc7=yF\xc7XG\x9d+\x87 ;\
 952 \x07~\x8b_\x83\x85\xcc\x981R\xe5\x8e/;2\xf66\x03\xb0\x7f\xea\x93\xbb\x9f\x9f\
 953 \xea\xe2k5\x19U\xca\x0cR4\x91\x8eoU\xca\xf2\xd9\xf9\xf9G>\xecgp\xdd\x87k\xf7\
 954 \xef\xd4\xeeL}\x1c\xafJG\xc6\xceJ\x97\xbb\x0e7a\xfb\x02\x06` \x10\xf0\x15\
 955 \xffG\xc0\x1f\xb0\x80k\xc1\x03!\x8e\xc7\x00\x00\x00\x00IEND\xaeB`\x82'
 956
 957 def getCOBitmap():
 958     return BitmapFromImage(getCOImage())
 959
 960 def getCOImage():
 961     stream = cStringIO.StringIO(getCOData())
 962     return ImageFromStream(stream)
 963
 964 index.append('CO')
 965 catalog['CO'] = ImageClass()
 966 catalog['CO'].getData = getCOData
 967 catalog['CO'].getImage = getCOImage
 968 catalog['CO'].getBitmap = getCOBitmap
 969
 970
 971 #----------------------------------------------------------------------
 972 def getCRData():
 973     return \
 974 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
 975 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
 976 \x00\x01$IDAT(\x91eQ1JCQ\x10\x9c\x97\xfc"(\xa87\xf0\x10\x9e@,\xbc\x83\x17\
 977 \xf0\x00Bn\x10R\xab\xd8XX\x04,\xc4Sx\x0b[-\xac\x144\x8a\x92\xdd\x9d\x19\x8b\
 978 \x9fD\xc5a\x18\x18\xd8]\x86\x9d\x86\xed\t\x02KH\x88\x82\x05\xd4/\xc6J\x03P\
 979 \x87\x8d\xd1\xc5\xe5\xa1\x01\x1b\xb2E\x97$\xa9h\xd2\xa4\x92b\xa9\xc4*\x9f\
 980 \x8e/\xda\xc2\x1e\x02\xb0\x01\x18\x80m\xc0\x7f\xd1\xfb\xd6\xda\xeb|\xdea6\
 981 \xc3\xde\x9e\xbf>-\xc3\xb2V\xa4,\xd9\x02i\xd2R\xdb\xd8\x8c\xdb\x9b\xf6\x00\
 982 \xec\x8c\xc7||t\x95\xb2\\\xe9Ld*\xd2\x19\x8apf\xaf\xc3\xdd\xdd\xfb\xbb\xbbN\
 983 \x00\x8a\xceT\x95\xfb\x85\x08g\xae\xe7\x14\xe1\x08e\x0e\xaa\x04t\x02\xc4R\
 984 \x952\x9c\xe5Lg8\xf2\xf7\xed\xa5f\nho\xd3\xc9h\xff@\x1f\xef}\xd0^\xb5\xcam\
 985 \x12\xa4d\x8b\x83\xad\xad\xa7\xf3\xb3\xf6\xb5Xt\xc3\xa1\xa5\xe5\x8bl\xdb\xfa\
 986 \xff%\xa0\xb5\xf6\xfc\xf2\xd2\x80\x93\xc9\xd5\x11K\xa4\x8a*\x8aT\x96(\xb2\\\
 987 \x12)\xc9E\xd9\xbe\x9e\x8e\x1bp\xbcjq]\xe7\xda\xfe\x14\x0c\x14 `\xf0\r2\xf7{\
 988 wG\xf1\xb3\xa7\x00\x00\x00\x00IEND\xaeB`\x82'
 989
 990 def getCRBitmap():
 991     return BitmapFromImage(getCRImage())
 992
 993 def getCRImage():
 994     stream = cStringIO.StringIO(getCRData())
 995     return ImageFromStream(stream)
 996
 997 index.append('CR')
 998 catalog['CR'] = ImageClass()
 999 catalog['CR'].getData = getCRData
1000 catalog['CR'].getImage = getCRImage
1001 catalog['CR'].getBitmap = getCRBitmap
1002
1003
1004 #----------------------------------------------------------------------
1005 def getCZData():
1006     return \
1007 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1008 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1009 \x00\x01;IDAT(\x91u\x91\xbdjTq\x10\xc5\xcf\xde\xfc\th\x14VH\x10\xfc(\xdcR\
1010 \x1bAlW+\x0bA\xb0Hoo\x91\x17\xf1E\x02\x11\xf1V\xbe@\xda\xecF\x10\xc5\x17\x90\
1011 \xb5\x10\x15Rxg\xce9cq\xb3K\x90x\x8a\x99S\xfc\xce\x0c\xc3L\xf0\xea\xe4\xcd\
1012 \xcb\xdd\xd7\xcfv\x01\x00\xb0=\xd6\x8bf#\xda\xed\x86\xcf\xb6\xaf\xdf\xfd\xba\
1013 \xd2\xc3{\xd7\xc6L\x15\x80\xaaM\xbb\xa0\xd5j\xd5u]\xb7S<:=;\xfe\xf2{$6\xd8?\
1014 \xe3\xc7\x85\xcd\x86\\W5\xf4\x9f,{~\x7fZ\xff\xd1y\x80\xb4\xab\\\xb5\xa3\xe1\
1015 \xddGQ~\xfa\xe0\xf2\x0c\x00\x92-h\xdbTIuE\xc3\xe1\x89n~8\x9a\xedm\x97d\xb2$H\
1016 %\x954\x99Nqp\xd0H\xca\x90\x8a\xaa\x94_\x9c\xbe\xbd\xb3x?DV\x842+\xa22\x1dQ\
1017 \x99m6\xfb5\x0cM\xb4\\)S5_\xf6\xf3E\x7f\x0ee"\x02\x99\x15\x81L\x90 \x014\x04\
1018 9\xd2\x8b\xfe\xc9\xb2\xaf\x88q\xde&V\x11f\x82*\x89@C\x98\xaa\xe7\xdf\x8e\x1f\
1019 \xffX\xe2\xd6m3\xbbLd\x9a\xac\xcc\tY\xe4\xd6\xfa\x0c\x00\r\x7f\xf8y\xff\xd1>\
1020 ~~\x07\x0c\x18\x00\xc0\xb5\xe7\xf8\xfe\xb5\xe9\x80\xbf3\x19y\x13g\xfcd\xb6\
1021 \x00\x00\x00\x00IEND\xaeB`\x82'
1022
1023 def getCZBitmap():
1024     return BitmapFromImage(getCZImage())
1025
1026 def getCZImage():
1027     stream = cStringIO.StringIO(getCZData())
1028     return ImageFromStream(stream)
1029
1030 index.append('CZ')
1031 catalog['CZ'] = ImageClass()
1032 catalog['CZ'].getData = getCZData
1033 catalog['CZ'].getImage = getCZImage
1034 catalog['CZ'].getBitmap = getCZBitmap
1035
1036
1037 #----------------------------------------------------------------------
1038 def getDEData():
1039     return \
1040 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1041 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1042 \x00\x015IDAT(\x91u\x901\xaa\x14\x01\x10Dkfg\xc1H\x14\x13\x03\x7fj\xa8\xe072\
1043 T\xcc>h\xe8=~\xe0-\xbc\x88\xb0\x970\xd1\xd4\xa3\x082\xdd]\xddU\x06\xb3h\xe4\
1044 \x0b\x8a\xa6\xe0U\xd0\xcb\xdd\xdd;\xcc\x0e\t\xa7\xadZ\xc5\xb6\x08\x08\xffa#\
1045 \xf7\xfb\xfb\xcf\x00$I\x9a\xe9\x99#\xfb\n\xd9\xd3\xdd$y\xb9|\xdd\xd6u\x05\
1046 \xf0\xfd\xc7\xcf&\x8f\xba\xaa*++\xff\x12\x11\x19\xf1\xe1\xe3[\x00\xdb\r\xf0H\
1047 \xba!\xbb\xbb\xab\x9ad&3\xab\x8a\x11\x95\x91\x99\xdc#+\x9f6\x01l\x9f\x98\xb7\
1048 3\xb7\xa4\xab|d\xa63\x15\xa9\x0cg*\xc2{\xaa\xe2\xcc\xde\x80\xcd,\xcf\xa0\xca\
1049 Eg\xb8JW!\x9c\xa9L\xed\xfb\xe1\x9be`3\x80\xe9\x7f\xc3U\x8eP\xc4U\xdbwWN\xa4\
1050 \xab<\x1c`\xe3\x1b\xe0\xb9}\x92G\xa2\xc49\x0e\xb7E\xb91\xb4\x1b\xa2\xfdz\x89\
1051 o\xd8\xfc\x02~&?\x1ei\xa4\xb1F\xd3\x96\xa4>\xde\xac\xb1%\t~\xb2\xe8=6\x14\
1052 \xdc\xc4\xf9\xd5\x8aZ4V-j\x98\xd6X\xb4\xda\x1e\xbb\xedF\xf5\xfa\x1b\xcb\xe5\
1053 \xcb\xcb\x07\x03\x15|B\xee\x10\xe0\x87X\x03\x1a\xd4\tS\xd0\xe0\xbcB\x01\x9c\
1054 \xf0\xab\xf0\x078 \x87a\xf5\xfb\xbfZ\x00\x00\x00\x00IEND\xaeB`\x82'
1055
1056 def getDEBitmap():
1057     return BitmapFromImage(getDEImage())
1058
1059 def getDEImage():
1060     stream = cStringIO.StringIO(getDEData())
1061     return ImageFromStream(stream)
1062
1063 index.append('DE')
1064 catalog['DE'] = ImageClass()
1065 catalog['DE'].getData = getDEData
1066 catalog['DE'].getImage = getDEImage
1067 catalog['DE'].getBitmap = getDEBitmap
1068
1069
1070 #----------------------------------------------------------------------
1071 def getDKData():
1072     return \
1073 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1074 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1075 \x00\x01(IDAT(\x91eR;N\x03Q\x0c\x9c\xf7v\x0b\x04\x8aD\x85\x94b\x1bn\xc0A\xe0\
1076  \xb4\xd0\xe5V)s\x88\\!\x02AA\x04R\x96\x04\xa4xl\x0f\xc5[\x90\x00\xcb\x85e\
1077 \x8f\x7fc\x97\x11HL\x92\xc0yDn\xb7\xbb\xf9<\x81?\xea\x00\x80>\x81\x93\xc5\
1078 \x02\x002\x91YJ\xa9\xb3\xd9\xd9\xfd]~|\xca]$\xdcE\xca=\xc9\x97\xe5\xb2\x07\
1079 \x00(\x9f\x9e\x11\xa1\x08I\x8a\x88\xcdC\x1e\xf6"e\x14MfI\xd6a\xc8\xd6\x01\
1080 \xa9\tM\x02\x90\x94\xb4lP\x9a\x8ci&\xb2\x906%D\xc8]\xee\xa0KR\xad\xda\xefa\
1081 \x04Mf"a\x06Rd\x02%"J)\x92$\xb5\xf2\xcaT3~K\xa9u\xdc\xedz\xfc\xc4 \x08-\xef?\
1082 ZR\x912\xb3\xdfv\xdd\xec\xf666\x1b\xb9\xcb\xect\xb5\xd28\x1e\xaeor\xff\xde\
1083 \xe6i\x0b\xc8\xbd\xbf\xbc|Z\xaf{\x00\x8d>\x91 \xa7fv\xc4\xf189\xcd\xe4\x84\
1084 \x07"&\x96D\xaf\xf3\xb9Hy\x00@\xd7\xd5a\xc0\xe1P\x1a\xfd\xee5\x02\x11\x19\
1085 \x01\xa0<\x03\xfe}H\x07.\xde\xde\xfc\xf1\xf1\xf5\xea\xea\xc7\xd9\xfe\xa0\x9d\
1086 \xb9\x02_\x06\xaeY\xf5\xbd\xb5\x05\x04\x00\x00\x00\x00IEND\xaeB`\x82'
1087
1088 def getDKBitmap():
1089     return BitmapFromImage(getDKImage())
1090
1091 def getDKImage():
1092     stream = cStringIO.StringIO(getDKData())
1093     return ImageFromStream(stream)
1094
1095 index.append('DK')
1096 catalog['DK'] = ImageClass()
1097 catalog['DK'].getData = getDKData
1098 catalog['DK'].getImage = getDKImage
1099 catalog['DK'].getBitmap = getDKBitmap
1100
1101
1102 #----------------------------------------------------------------------
1103 def getDOData():
1104     return \
1105 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1106 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1107 \x00\x017IDAT(\x91uQ1j\x94a\x14\x9c\xef\xdf\x1f\x8b\x15\x84\x10\x8c,\x98"\
1108 \x8d\xe2\x01\xbc\x8d\x85M\xeaTv9\x83\x85\'\x10\x82\x17H\x97\xde\x0b\xa4\x88\
1109 \xddJjAY\xbb\xe4\xcd\xbc\x19\x8b\x7f#\xb1p\x8a\xe1\xf1\x98y\x03\xf3\xc6\xea\
1110 \xcd\x05\x1e\xd02\xca\xb0\x7f~{\xffL\xbb\xef\x07\x87\x06\x0c\xe8\x11\xcf\x00\
1111 >\x9d\xbf\r\x90\xc0\x1d;\xb2\xd7O0\xe6\xf5\xf3\xd3\xd3\x90\x91BZ\n\xb9\xbd\
1112 \xbc\x9c\x01$\xf8\xf1\xeb\xae\x17u\xbb;\x9d\xccnn\xb7)\x86\xe5\xaa\x90\xab\
1113 \xe3c\x03s\x1b\t\xba\xd3N\xb7\xd5\x91\xec$q\xaa\xc2r1U&\'R\xc0\x0cY~Pko\x98G\
1114 2\xadR\xe5*\x93\xa9\niR\xc0\xe8\xee1F\x92$\x00\xf2\x7f\x8ci\xfa\xbd\xdb\x8d-\
1115 pxv\xa6\xdb\xdb\xb0B\x99\x0c\xeb\xe0\xea\xaa\xa7\xf9\xdd\x87\xaf\x92\xa9\x96\
1116 L\xf9\xe5\x8b\xa7_>~\x9e\x0cd\x1f*W\xa5*\xf7\x95\xfb\xbb\xea,j\xca\x94\xa5\
1117 \xee6\xa0\xd9\xc0\xbe8rq\xba*\x89\x93\xe2\xfe\xb6\xba\xd5i\xff5P\xd3f3\xc8\
1118 \xa8-\x0erL\xabi\x8c\xcd\xd1\xba\xdbKu\xb6\xd5\x01<n\xfe}\xe4\xc2\xafn\xaew\
1119 \xeb\xa3\xd7\'\xe7\x8f\xd6\xcb\x80?\xc4\xb2w\xdfN\xf3\x0b&\x00\x00\x00\x00IE\
1120 ND\xaeB`\x82'
1121
1122 def getDOBitmap():
1123     return BitmapFromImage(getDOImage())
1124
1125 def getDOImage():
1126     stream = cStringIO.StringIO(getDOData())
1127     return ImageFromStream(stream)
1128
1129 index.append('DO')
1130 catalog['DO'] = ImageClass()
1131 catalog['DO'].getData = getDOData
1132 catalog['DO'].getImage = getDOImage
1133 catalog['DO'].getBitmap = getDOBitmap
1134
1135
1136 #----------------------------------------------------------------------
1137 def getDZData():
1138     return \
1139 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1140 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1141 \x00\x01\x99IDAT(\x91M\x8f=kTQ\x10\x86\xdfs\xce\xdd\xbb\xbb\x97\x15\xa3d\r\
1142 \x9b\xb0\x85\x04\x14\xc9?\xd0:\x88\xe8Bl\xf4\x07\xd8\xd8XX\x1aAl\x04\xfd\x01\
1143 \xd6\xda\x88M,C\x1a\xb1\xd1F\xb0\x10;EA\xb6\xca\xfa\x955\xaew\xcf\x99\xafcq\
1144 \x17u\x8aa\x8a\xe7\x9d\x99\xc7\x9d\xbc5\x9a\xc6\x19\x00\x00$\x12\x894\xceBY}\
1145 \xba\xb3S\x86\x16\x80\x9c\xb3\x99\x99\x99\x88\x98Y\xf1\xad\x9e\xde\xdf\xba\
1146 \x91\x01\xcb\xa6\xa6\xa2*"V\x84\xfe`\xd0\x86G\xce\x96\xff\xd5x<.\n_d\xe4\xc9\
1147 \xe1\x0fQ\x15\x152a\xa6\xf5\x9f$\xab\xefm0\xb0V\xcbl\x11\xa9\xaa*\xe7\\\xc0\
1148 \xccr\x16UVa\x95\xe1\xaf\xfa\xf2\xc7\xaf]J5\xef\xf5\xce\x8f\xd0\xef#\x84\xbf\
1149 \x17\xcc\xccG!Q!\x15\x16\xa6,\x9b\x9f\xbfW\x94\xee\x9e9\x11.\x8cf\xbb\xcf\
1150 \x9c\xf7\x8d^\x13\x10\x11\x1f\x89D\x95\x85\x92r"Z\xfe=\x7f\'\xb4\xdf)\xe6\
1151 \xf7n\xa77\xaf\'\xd7\xaex\xefC\x08\xce\xb9F\xddg\x8a\xac\x92\x84\x13SR\x9e\
1152 \x18\x9f\xda\x9f\x96\x07\xd3\xf6\xcd\xedr\xfd\xf4\xea\xa3\x9d\x86\x0e!,^B\
1153 \xacI\x85\x98\x13SJ\xf1\xe9Jg\xde\xc2\x83W\x1f\xf8\xc9\xe3\xa3[W3\x91\x99\
1154 \x01p\xce\x01PU\x8fX\xb3p\x12JL\x91\xd2\xdb.\xaeo,=\\\xebU\x9b\x97\xf2ph\x9d\
1155 \xce\xff\xc6\x00\n\xc4C\x12^\xee-\x9121\'aj\xa7\xf1Ji\xe7\xce\xe6\xec\x1c\
1156 \xd0\xacoh3s\xb8x\x0c_\x0e\x10\x81\x1a\x8b>\x03J\xbcx\xfe\xf2x\xf7H\x03\xa9j\
1157 3\x00\xf8\x030\xe7M\xc9\xeb\xfd~\xae\x00\x00\x00\x00IEND\xaeB`\x82'
1158
1159 def getDZBitmap():
1160     return BitmapFromImage(getDZImage())
1161
1162 def getDZImage():
1163     stream = cStringIO.StringIO(getDZData())
1164     return ImageFromStream(stream)
1165
1166 index.append('DZ')
1167 catalog['DZ'] = ImageClass()
1168 catalog['DZ'].getData = getDZData
1169 catalog['DZ'].getImage = getDZImage
1170 catalog['DZ'].getBitmap = getDZBitmap
1171
1172
1173 #----------------------------------------------------------------------
1174 def getECData():
1175     return \
1176 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1177 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1178 \x00\x01*IDAT(\x91m\x8e=J\x9da\x10\x85\xcf\xa7\xaf W\t\x88!\x11+\xb9M\x9a\
1179 \xec \xab\xc9\x02l\xc4\xdaJ\xd2\xa4uC. \xd8\xaa\x95"61\x89\x17\xa3\xa2\xef\
1180 \x9c\x1f\x8b\xcf+\n\x0e\x87\xe1p\xe6af\x86\xc7\x93/\xf0\r\xc6\xb2\xed\x0e\
1181 \xd3\xe8v7c\x03\x86\r\x136\x004\xf8\xdf\xe2\xa7}\x00\x80\x90,D\x88\x13\x8dB\
1182 \x98\x10a\xec\x84\xb3\xe3\x9f\rh@\xc0\xab9\xe1\x84\tc&\x84\x19T\\1\x87\xa5\
1183 \xcf\xeeh0\x00\xbfK\xc7\x95\x10\xa9\x98I\xc1\xa4\xd1\xda\xe4fX|D\x1e^\x1e\
1184 \x98\xeb\x99\x1b\xd7\'5\xb4\xfb\xe5\t\xda\xc7\xdd\xbd\x1f\xdf\xbf\xfd\xbe\
1185 \xbe\xa5"\x8b2eJEQ.I\x14\xe9\x927\xd6W\x0f\xb6/\xda\xf5\xe9\xe6\xe5\xec\xc3\
1186 \xc5\x9fVr\xc9\xa4\x8b\xeet\xc9E\x153\x0f\xf5_\x13`\xda\xf0`j\x1c\xbb\xf8b4\
1187 \x9a\xcep<EK\x06<\x1c\x01\x9b;;\xfd\xec,U\xaez\xee\xbd\xbb\xca\xe4\x98\x84\
1188 \x15ji:\xfdux\xd8\xb6\x80\xe5\xbb\x19\xd6V\xc2Ji$\xc0J1\xac\x88!CA\xca\xed\
1189 \xdf\xaf\xc0p\x0e\x10\xf0[\xf1\x95\xc1+\xb3\x00<\x01\xfcl\x81#D\xaf\xf8n\x00\
1190 \x00\x00\x00IEND\xaeB`\x82'
1191
1192 def getECBitmap():
1193     return BitmapFromImage(getECImage())
1194
1195 def getECImage():
1196     stream = cStringIO.StringIO(getECData())
1197     return ImageFromStream(stream)
1198
1199 index.append('EC')
1200 catalog['EC'] = ImageClass()
1201 catalog['EC'].getData = getECData
1202 catalog['EC'].getImage = getECImage
1203 catalog['EC'].getBitmap = getECBitmap
1204
1205
1206 #----------------------------------------------------------------------
1207 def getEEData():
1208     return \
1209 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1210 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1211 \x00\x00\xf2IDAT(\x91\x85\x911JCQ\x10E\xcf\x83\x07.\xc0"\x95X\xb9\x04\x17 \
1212 \xae\xc7\xd6\xc6]\xb9\x81 \xb8\x80,!\x04S\xdb\x86\x99;w,\xbe\xf9\xc6B<\xcd\
1213 \x1bx\xe7^\x18f\xf0\xb8e\xc5\x10FF&D\x980\'\x11"\xc4\xc9\xa4&\xf0\xf2t\x07\
1214 \xd8\xb8\xbb\xdc2e\xabZe\x15YV9\xddY\xfd\xfa\xf4>\x97\xea\x8f\xcf,w\xb9\xb3\
1215 \\\xd5Y\xce\xea\x94\xb3:\xe4(g\xfa\xe6\xfa\n416\xe5\x96\xad\xea\xaa\x8e\xb2\
1216 \xaas\xf1\xe4P\x87\x9cv\x96A\x93\xedC\xdd?\xebp\x90\xa4T*\x17"23\xe2\xfcdf\
1217 \xde\xde\xc2\xdb\x04\xa4\xca\xcc5\xf0\xfd}\xa9G,\x020\x81*I\x8a\x8cs\x7fD\
1218 \xe4e\xf7Z\x01\x8c\xe3\xf1\xb8\xd9l\xba\x1b\xe8\xbf\x01\xc6\x18\xbb\xddn\xda\
1219 ^\xd4\x7f\x03\x80\xedi{\xb5\xd7\x03\x8e1\xf8\xc5\x80\xfe\t\xec\xf7{\xdb\x18c\
1220 I\xb6\xed\xefaY\xd4g\x80/\xd4.~\xec\x91&]\x97\x00\x00\x00\x00IEND\xaeB`\x82'\
1221
1222
1223 def getEEBitmap():
1224     return BitmapFromImage(getEEImage())
1225
1226 def getEEImage():
1227     stream = cStringIO.StringIO(getEEData())
1228     return ImageFromStream(stream)
1229
1230 index.append('EE')
1231 catalog['EE'] = ImageClass()
1232 catalog['EE'].getData = getEEData
1233 catalog['EE'].getImage = getEEImage
1234 catalog['EE'].getBitmap = getEEBitmap
1235
1236
1237 #----------------------------------------------------------------------
1238 def getEGData():
1239     return \
1240 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1241 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1242 \x00\x01#IDAT(\x91\x9d\x8f!NCa\x10\x84\xe7\x7f<P$\xa8R*p5`\xaa\x90\x1c\x82;\
1243 \x90\xfa:\x12,\xa9@r\x00\x1c\x17\xa8Ar\x86^\xa0\nH\xa0\xc1T\x10\xfa\xcf\xec\
1244 \x0e\xe2\x15\x02H\xbel&\x93\xc9\xec&[\xde\x80\xc4\x86\xfc\xad\xdf\xa3\x1fa\
1245 \x9b\xc0\xee\xe5%\x00g"\xd3\x11V8d\t\x92IKIZ\x02\xf9<\x9b\xb5\x00\x0c\xc7\
1246 \xe3\x13"\x1c\x01\xd2\x11&M&\xe9J\xb3f\xad \x9b\xc3C\x01\xed\xce\xc9Ist\x8c\
1247 \xde\xfe\xe6|\x04"\xb8\xe6\xd6\xe9{\xf3\xb0\x9d\xac\x96\x1a\xc9R\xe9\xf5v\
1248 \xee\xefKD\x94R\x00\xd8\x86a83>\x96\xb7\xe0\xe3\xf6\xc1\x05\xdc\xfa\x8bR\xca\
1249 j\xb5j\xbaw7\x19l\xbb\xbe\\k\xbd\xcaX\xd7\xe7+\xff\x04\xc8\xcc\xe6O\xdb\xb6-\
1250 \xca\x1f\xdcK\xf3W\xdf\xce\xcc2\x1a\x8d&\x93\xc9r\xb9\x8c\x08I\x92H\x9d\x9f\
1251 \xbd\xda\xba\xb9\xdb\x93\x94\x19\x92"\xa2\xdf\xefO\xa7\xd3\x02`<\x1e/\x16\
1252 \x0b\x92$k\xad\xb5\xd6\xce\x90\xec\x9cD)\x86\xc3\xe1|>o\x01\x90\x1a\x0c\x06$\
1253 \xa5\x90\xbaEJ\xea\xb4;\xdf\x81\x7f\xf0\t\xfe\xd7NcxZ\xa4\xd1\x00\x00\x00\
1254 \x00IEND\xaeB`\x82'
1255
1256 def getEGBitmap():
1257     return BitmapFromImage(getEGImage())
1258
1259 def getEGImage():
1260     stream = cStringIO.StringIO(getEGData())
1261     return ImageFromStream(stream)
1262
1263 index.append('EG')
1264 catalog['EG'] = ImageClass()
1265 catalog['EG'].getData = getEGData
1266 catalog['EG'].getImage = getEGImage
1267 catalog['EG'].getBitmap = getEGBitmap
1268
1269
1270 #----------------------------------------------------------------------
1271 def getESData():
1272     return \
1273 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1274 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1275 \x00\x01\x1fIDAT(\x91}\x91\xadN\\Q\x14\x85\xbfs\xe7\xb6\x08B%\t\x02\x05H\x10\
1276 \xf5\x18\x9e\x01Y\x8d\xe8+L&\xc1cx\x16lUU-\x83gT+\x9a0\xc9\x84\xce\x94\xb9g\
1277 \xff,\xc4\xbd\x13:\t\xe9\xce\xca\x97%\xf6^b\xed"\xde&\xb7\xfd\xbb*\x02\xc6c@\
1278 \x99d\x12!\x0f\xc2\xe5\x8e\xbb\xcc\xf4\x0f\x97ww-\x00\xd2\xcf_D\x10!\xb3\x9e\
1279 \x83\xaa\xc9\xaaj\x95Y9<Lh\tT\x04\x01\xf1w\x91/\x0b\xed\xed\xd7\xd1\x8eK&U\
1280 \xa9\x0e&\x8db\xf9L\x93\x00\x01\xbe\\y\xdc\xc2M\xbbz\xbaXwu\xb3\xbd\x11U\x18\
1281 \xd0\x00\x10\x92\x8d\xee\xbf\xf8o/_\'\x1f\x1e\x8f\xbay\xd9\x8a\x1fn<\x93\x06\
1282 \x90\\\xf2\xf6\xec\xe4\xcfIr=\x19\x9d~n\xf5Q\xea\xa4\xbaa\x95*\xb2L\x9aL\xfa\
1283 \x98\x1f\x8f\x0f\xbb\xe7u}\xd9}\x9f~[\x7fZm\xb2\x07\x82K\xeeN\xe9`tu\x95\xb3\
1284 \x19C-C\'\x03{\xe3\x86G9>\x9eO\xa7mBc\xce\xc1\x81\xcc\xf0\xc0\r\xb3b\x86;=\
1285 \xdd\xfb\xc6\x89H(\xab\xedG\xfe\xe7\xc7\xfd\xbc\x02v\xb4J\xaf\x8f\xc6\r\xe6\
1286 \x00\x00\x00\x00IEND\xaeB`\x82'
1287
1288 def getESBitmap():
1289     return BitmapFromImage(getESImage())
1290
1291 def getESImage():
1292     stream = cStringIO.StringIO(getESData())
1293     return ImageFromStream(stream)
1294
1295 index.append('ES')
1296 catalog['ES'] = ImageClass()
1297 catalog['ES'].getData = getESData
1298 catalog['ES'].getImage = getESImage
1299 catalog['ES'].getBitmap = getESBitmap
1300
1301
1302 #----------------------------------------------------------------------
1303 def getESPERANTOData():
1304     return \
1305 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
1306 \x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
1307 \x00\xbbIDAT(\x91\xcd\xcc\xb1\n\x82P\x18\x86\xe1\xf7\xc8!\x84h;\xb8\xd5\x18N\
1308 \x0e98\xb9G\xa3W\xe05x\x05]\x84\x83\x9bS]\x83\x108\xd6\xec\x12\xb5\x05\xd1f5\
1309 Td\x19\xd8\xea\x10XN}\xe3\xcf\xff\xbc"\x9c\x85\x0f\xcb\xb4dUU\x08!\x00\x98.\
1310 \xa7\xb7t\x9f>i\xda\x9e\x8b\xb4LK\xba#W\x8b\xb71\xfe\xd0G\x08\x81q6zt\x1a9\
1311 \x00\x1a@\xb4\x8e\x08V\x01\xde\xc2#/\xf2\xefd=0\xee\x8fq\x0c\x07[\xd9(]\xfd\
1312 \x14\x90\x00JW$\x93\x84ky\xfd\t\x03\xc8(\x8b\xee\x83\xd7\xa0[?f\xc7\xec\xfb\
1313 \xc0|3/(\xe96\xbf~\x9e\xd6\x16\xfeO@\xb2\xe3D\xc9\xa3\x95>p{\x03\xe8\x982\
1314 \xccS\xd0\x19\xaa\x00\x00\x00\x00IEND\xaeB`\x82'
1315
1316 def getESPERANTOBitmap():
1317     return BitmapFromImage(getESPERANTOImage())
1318
1319 def getESPERANTOImage():
1320     stream = cStringIO.StringIO(getESPERANTOData())
1321     return ImageFromStream(stream)
1322
1323 index.append('ESPERANTO')
1324 catalog['ESPERANTO'] = ImageClass()
1325 catalog['ESPERANTO'].getData = getESPERANTOData
1326 catalog['ESPERANTO'].getImage = getESPERANTOImage
1327 catalog['ESPERANTO'].getBitmap = getESPERANTOBitmap
1328
1329
1330 #----------------------------------------------------------------------
1331 def getETData():
1332     return \
1333 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1334 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1335 \x00\x01\x84IDAT(\x91]\x8b\xb1k\x93a\x18\xc4\xef\xfd\xf2\x19+\x16\r\xb4J\x1a\
1336 \x08\xb1\x9d\x84n\x8e\x0e\x1d\xfc\x0f\n]\xea\xe4\xe2"\xb88\x88\xa0\xb848\x0b\
1337 .nNN\xd9Dpv\x15q*(Xj\tJ\xc1\x04Sc\x92~y\xefy\x9es\xa8\x8az\xfc\x86\xfbq\\\
1338 \xc2\xf6*&c\x9c$\x0c\xd9\x10\x19\x990\xc0\x80\n\xc8@\xfe]\x16Pb\xfc\xed\xfe\
1339 \xcdG\x00"\x14r\x8f\xb0p\xb7l\xe1\x162w\xba\x9b\x1b\xc3\xe9|q\xfbq\x89\xaa\
1340 \x0e\xa6\xcf\xa3\x81\x87{\x04#{\xb2T\xb6\xe81\x9d\xee\xb1b6d#\xc9\xf6r\x13@\
1341 \x89\xb5\xc1rc\xcebf\xe1\x116\'\xce]\xbcS\xab\xd5=bRU\x87\xfd\x07RE\xa7\xb95\
1342 \xcf\x9f\xc5\x05$w\xa4t\x17\xe8K\x06\xd9\x93\xb7\xdd\xe1li\xa3\xdd;8\xba\xb4\
1343 ;\xb8\xd2\xa8\x1f\xde\xbbzC\xca\x12S\xea\x8c\xc7\xaf\x0b\x00\x80K\x94(p\x9a\
1344 \xeb\x1b\xed\xde\xc1\xd1\xaaE\\\xeb<\x1f\x1e7\xa4\xfc\x0bX\x04\n\x00\x92I&d)\
1345 \xa7\xa2z\xb5\xbf\x15\xca\xad\xc5\x0f/?n\x9f95\xfas\x80\x18\x81D uo\xe9\xcb\
1346 \'\x98\xc9r\x9ecg\xf3\xe9\xf7\xd3\x8b\x0c-\xfc\x18u\x9fm\x95\x9a\x88\x84Yj\
1347 \xaf\r{\xef\xca\x00j}\xd3>A\x8a,s~\xb8s\xfd}s\xdd\xcd/\xef\xbd)8S\xce2\xc2\
1348 \x1c\xc7\x0e\xa0\x0c\xa0\xa0aeE$\xcca,\xc8u~\x15L\x9d\x96\xcc`\x06\xf7\x13\
1349 \x02HS \xfe\x02\xff\xea\x7f\x13\x80\x9f!\n=\xa6\x88\x1e\x1d\xea\x00\x00\x00\
1350 \x00IEND\xaeB`\x82'
1351
1352 def getETBitmap():
1353     return BitmapFromImage(getETImage())
1354
1355 def getETImage():
1356     stream = cStringIO.StringIO(getETData())
1357     return ImageFromStream(stream)
1358
1359 index.append('ET')
1360 catalog['ET'] = ImageClass()
1361 catalog['ET'].getData = getETData
1362 catalog['ET'].getImage = getETImage
1363 catalog['ET'].getBitmap = getETBitmap
1364
1365
1366 #----------------------------------------------------------------------
1367 def getFIData():
1368     return \
1369 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1370 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1371 \x00\x017IDAT(\x91m\x91\xbdj\x94a\x10\x85\xcf|~\xa2\x84\x15\x14\x02\n\t\x16\
1372 \x92"V\n\xb6\x96^G\xaeB\xd2j#\xf1JR\x08\xd6\x16\x06\xc4J;+\x05\xd1\x904\x11$\
1373 \x01C\xb2E\xf2\xbeg\x9eI\xb1\xcb\xe2\x8a\x0fS\xcd\xcf\x813\'\x8e\x8e\xcf5gX{\
1374 \xf6Y\rM\x86\xaf\xbb\x8fWn\xcaH\xcc1\x00\xa7g\xd3q\x90\xee\xadN$U\xd5\xab\
1375 \xedM\x8aLm>\xb8]U\xb3\xe6\xdf|\xfb\xd9F\xa4\xd9@\xd2\xaf\x93K\xa3L\xea\x7fD\
1376 D3#(\x99\x8b\xf5T\x82]\tUK\xf2*\x14\xd1L\xe8\xc9\xc7\x9d\xe7\x1bG\'-\x93\xd6\
1377 \xcbY=)h.\xbbz\xd2:6-Y_\xbd\xf1\xe6\xe5\xfbQ\x17n\xe6\xb2\x93YN\xba\xcb\x89M\
1378 \xcf\xea\xa6\x19wZ\xd2{5#]\x8c\xc2UU\x14\xd0]6\xcd\x00\x99\x95\tI\x02\t\x14 \
1379 \x11?\x0e\xfe\xdc_\xbf\x05Ti\xeb\xf5~7\xdd\xbc}\xb1\xc1\xb2sI\x11\xf1\xe9\
1380 \xcb\xe18\x8c\\\x0bEH\xa1\xd9v7U%\xfdS\x92\x04m\x14,^~\xf7\xceu\'\xb6"BK\xc4\
1381 \xe2&\xbe\xef\xff^\x04\xf9\xe8\xe1\x9e\xd4\xa4\xe1\xdd\x87\xa7\x93\x15\x19d\
1382 \xbcH\x1b\x9dM\xa7W\xd3th\xf7\xea\xb0\xa3\xa0\x00\x00\x00\x00IEND\xaeB`\x82'\
1383
1384
1385 def getFIBitmap():
1386     return BitmapFromImage(getFIImage())
1387
1388 def getFIImage():
1389     stream = cStringIO.StringIO(getFIData())
1390     return ImageFromStream(stream)
1391
1392 index.append('FI')
1393 catalog['FI'] = ImageClass()
1394 catalog['FI'].getData = getFIData
1395 catalog['FI'].getImage = getFIImage
1396 catalog['FI'].getBitmap = getFIBitmap
1397
1398
1399 #----------------------------------------------------------------------
1400 def getFJData():
1401     return \
1402 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1403 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1404 \x00\x01\xccIDAT(\x91M\x91?h\x93a\x18\xc4\xefM\xbe\xb41%\xd6h\x12\xdb\xb4\
1405 \xc5j\xb1h\x87\xd2V\x1d\\\\*B\x9d\xdaA\xaa\x83\x83\x93\x14Q\x91\x0e\x82\x15\
1406 \x8a\xe8\xe6"\x0e\x05\x17\x15\x07EA\xa7X\x10\xaa\xa0\xb4\x82CA\xc1\xb8Y\xed\
1407 \xd2\xa4(\x8d&5\t\xdf\xfb<\xcf9\x04\xfflw\xc3\xc1\xef\xee\xdc\xd2\xf9\x99\
1408 \x8507{\xe7\xd3\xec\x8e\xf7\x89\x96\xc8\xe5b\xf7\xd9\xce\xca\xf8\xf8\xc1\xb1\
1409 \xcaU\xe4\x0cbh\x18\xc4`\x86\x9aA\xe0\x86{.>\x7f0);s\x8d\xc2G\xd6j\xae#\xd7\
1410 \x9e\xdd6_\xa8\xaf\xa6\x87\x838BP\x8cb\x14\xa5\x18o\xcfm\x06w\xe5\x89+\xf4oy\
1411 \xfb2Z.[\xbd\xde\x92J\xd5\x05\x87\x85\x8b\x07\x86\x90\xa4*\xc5\xe8\x95^\xd9\
1412 \xd1\xe6\x10Z\x90O\x0c\x9d\xe9\xdb\x9f(\xaf\xd5\x85n{&\xde\xd7\xbb\xf1\xa5X\
1413 \xa8\xb6z\xa5*\xa7\xf3\x97b\xf5j\xfa\xa4\x94\xeeyt\xf7\xce\x85\xd3\x91\xb5\
1414 \x91c.\x1e\x7f\xfc9X\xf1m_k\xb1\x87?\xbb"\xbbvo\xb0\xd5+)4/\x99SB\t\xb3\xa7\
1415 \xc5\xbc@\x10\xa4\x07\xf6\xe5K\xc9\xa5H\x7f\xa3\xb3\xcb\x99\xbeZ\x89\xae\xee\
1416 \x1d\x18<$\xbeLS\xe2\xfa\xad\xd8V\x96&\'2\x8f\x9eb$\x82\x13?\x1c\xae\xe9\xcd\
1417 Q\xacU\x9b\xcd\xd0$\x16\xa57\xd6\xc8s/\xae\xf4\x94\nZ\xddd\x10\xfd6x\xe4\xe8\
1418 \xe2T\x80\xd0\x94N\x94b\x10\xa5WzcS\x10l\x9f\xbd\x91igqb,\xfbl\xbeQqx\xf3=\
1419 \x80\x98hT\x94\xfeo\xe0\xcf2!8\xf3\x9a\xc7\xf7p\xd4\xfb\xfb\x1f\xb8\xbc\x0e\
1420 \x84\x08\xd00\x8fH*\tm"\x11\xa2Ps\xa2\x10\x83\x10\xcb%\xbc\xbb\xb0`\xebT\x03\
1421 \xcc\x1c\xa6~A\x0c\xa1!l\xfe\x8a\x7f\xd6\xfe\x13b0\x00\xf8\r\x008F\x8c]\xb5\
1422 \x85\xb4\x00\x00\x00\x00IEND\xaeB`\x82'
1423
1424 def getFJBitmap():
1425     return BitmapFromImage(getFJImage())
1426
1427 def getFJImage():
1428     stream = cStringIO.StringIO(getFJData())
1429     return ImageFromStream(stream)
1430
1431 index.append('FJ')
1432 catalog['FJ'] = ImageClass()
1433 catalog['FJ'].getData = getFJData
1434 catalog['FJ'].getImage = getFJImage
1435 catalog['FJ'].getBitmap = getFJBitmap
1436
1437
1438 #----------------------------------------------------------------------
1439 def getFOData():
1440     return \
1441 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1442 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1443 \x00\x01BIDAT(\x91m\x91\xbdJ\x03A\x10\xc7g\xb9\x15\x9b\xdc\x15\xe1.\x06\xc9\
1444 \xc5\x0f\x08>\x85\x85\x85\xbe\x81\x85\xef (\xc4\x8f\xdaN[}\x02\x0b\x1f\xc0\
1445 \x07\x10\x11\xb1\xb1M!\x87"g\xd0\x90\x8bB\x8a4ffv\xc6bc\x88&\xbfbXfv\xfe;\
1446 \xfb\x1f3\x18\x0c\xe0\x97\xb0\xde}\xee7\x1a\xf3Y\xbf[\x11\x11\x00\x90),\x00\
1447 \x94J%\x00P\xd5\xe3\xd3$.\x0e\xf6\xcbI\x14E\xaa\xea\x93\x93t:\x1d\xeb\xb5}\
1448 \xb9]0\x7f\xe4oC\xd2Y\x18cF/\xf8\xdb\x04@N\x84\x1d\xf2\x7fa\x8f\x9f\xd0\x86\
1449 \xb5\xee\xd1Y\xdc\xee9fa\xa7@HN\xb7\x0e?\x91\x94X\x90\x95H\x90\x84X\x97\xaa\
1450 \xf6\xee\xe2\xc5d\x00\xc9I\x93\xdfsu\xac\xc4\xca\xa4\x84J$DJ(DB\xe8\x0fs\xf5\
1451 \x95\xd6\xf5\x83]\x0b\x9e\xf6\xca\x95|\xc8\xe8\x94I/\xdb;\xdb\x0bWH\x82\xac\
1452 \xc4#m\x1fW+\xf6\x11Z\xb6\xffU\r\xc3\xd0\x8f\xb8\xd9\xec)\xe2\x10\xe5\xfe<\
1453 \x9e\xfe\x801\xe6uw\xd9z\xbf}\nI\x85\x10g\x99\xe4\xcddf+"c\xcb\x17\xe3 \xf8\
1454 \xae\xa5I`\x8c\x81?\x18\x80Q\x8f)\x8ab\xbc\xc54\xcdoa}\x03n\xb2\xac6\xb9]\
1455 \x10a\x11\xdf\xf0\x03x0_\xe6\x0b~m\xe3\x00\x00\x00\x00IEND\xaeB`\x82'
1456
1457 def getFOBitmap():
1458     return BitmapFromImage(getFOImage())
1459
1460 def getFOImage():
1461     stream = cStringIO.StringIO(getFOData())
1462     return ImageFromStream(stream)
1463
1464 index.append('FO')
1465 catalog['FO'] = ImageClass()
1466 catalog['FO'].getData = getFOData
1467 catalog['FO'].getImage = getFOImage
1468 catalog['FO'].getBitmap = getFOBitmap
1469
1470
1471 #----------------------------------------------------------------------
1472 def getFRData():
1473     return \
1474 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1475 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1476 \x00\x01<IDAT(\x91m\x91=\x8aTQ\x14\x84\xeb\xbc~\x06#8\x89\x82\xb4f.@p\x03F\
1477 \xc6\x82\x1b111\x1614\x11c\xdd\xd3lA\xcc\x8c\x9cn\xee=\xb7~\x0cz\x04\x03\xbf\
1478 \xa8\x82\x82*\xaa\xea\xdd\xd7\x1b\xfc\xc5\xf4\xdb\xd7\xd7\x92\xe6\x9c\x92HV\
1479 \xd5\xb3W/|\x0bN\x100\xb0\x03x\xf3\xf2\t\x808v\x8e\xc7\x07I\x00$\xb1\x9d\xe4\
1480 \xde\xc7\xcf\xe1rw\xd6\xfa\xf5\xfe\xc3\x0e\x00\xc1\xef\xf3\x92b\xfbt:%\xb9\
1481 \xb8\xabJ\xd2\xf5\xcf\x1f\xee\x99\x9ex\xf8\x88\xc0\x06#\x8e\x14\xd9T\xb6mKRU\
1482 \x17a\xdb=<\xa7\xd7L\xb7\x81\x9d\xb4l\xc9Rh%\xd9\xb6-\xbe\xd4\t\x00\xcf\x99\
1483 \x9e\xeeU\xdd\r\xec\xdd\xb4#y\xd9b\x0e\x87\x83m\x03\xfb\x06\xbb\xaa\xcasf\
1484 \xb5\xbb\x8b4\xb07Me\xc9\x94I\xe7\x1f$%IOu\xa7\xd7vI\x18M\xd9\xa4\x97\xcc%\
1485 \xfb\xae\x8dt\xa7\xd5\x9d\x9e^\x0b\\\x06\xf61Hz\xd1\xa4\x16\xfd\x1f\xe6\x0c\
1486 \x97\xd7*\x8a\xc0~\xee&}\xff\xea \x82\xdc.\xfb\\~\xac\xaa\xaa:<>\x9a,1Z\x06\
1487 \xf6\xf3\x99\x9f\xbe\xdf\x8c\xd1\xe7\xc1\xdb\xd1O\xaf\x8e\xdd\xbd\xc6h\xa9\
1488 \xbb\xc7\x18\xcf\xbf|3\xeen\x06\xf0\x07\xee\xad{fq\xbe!N\x00\x00\x00\x00IEND\
1489 \xaeB`\x82'
1490
1491 def getFRBitmap():
1492     return BitmapFromImage(getFRImage())
1493
1494 def getFRImage():
1495     stream = cStringIO.StringIO(getFRData())
1496     return ImageFromStream(stream)
1497
1498 index.append('FR')
1499 catalog['FR'] = ImageClass()
1500 catalog['FR'].getData = getFRData
1501 catalog['FR'].getImage = getFRImage
1502 catalog['FR'].getBitmap = getFRBitmap
1503
1504
1505 #----------------------------------------------------------------------
1506 def getGBData():
1507     return \
1508 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1509 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1510 \x00\x02\x02IDAT(\x91\x05\xc1[HSa\x00\xc0\xf1\xffw\\\xabV\x94\x87E\x9aF\xa2v\
1511 \x81\xa4\x87(\xa8\x91\x10\xd1\xcd\x11E>D\x99E\t\x15B\x12H \xf4\x10\x96\x96\
1512 \x11]\x9eR)C\xe8\xc1"\xe8\x86\xb3\x0b\xb9.b\xb9\xa02\xcb\xb5(\xa6\xa5Y\x99\
1513 \x8a\xae]\xce\xce\xce\xb6\xef\xeb\xf7\x135\xb5\xed\xee\x82q\xbc\x1e\xe5\xde\
1514 \xdd\x11\x98%\x95Z\xb1\xcc\x91\x7f\xa7N\xe8\xce\xe0\x86\xcaO\x81\x88Bn/J\xa4\
1515 [/\xcd(?\xdc\xd0\xa5Ss\xaa}\xe4\xaf\x94FL\xfa?\xc8D\xf2\xc7o\x195\xa4|\xf7Z~\
1516 \xe9\x8d\xc4\xe4\xe0O)\rS>\xb8)\xc3!\x9f_\xae\xdf\xd6\xa6\xa14\x05o\x83\x0e\
1517 \x91\x9b\':\xda\xf3\x1c\xf1h\\\x88\xfe>\xf1-\x186D\xbe#"\x8eW\x0b\xd7\xc6\
1518 \xa6\xa7\xb3\xe3\x06D\xa5\x86\x00@\xf0fXg\xcbf\xbc\x8f\xb32\xa2\x0c\x0c`\x8e\
1519 \xe5d\x849YC\xc3\x99+\xdd\xce\xd0?,\x0b\xc0\xe6\xd6zr\xb5\xd5\x0b\xedS(\x18Q\
1520 \x14-\xe7B=\xfdA\xfa\x02\xbczO\xd51\x06\xbfV\xcd\x8b1\xd7R\xce\x05v.\xda\x94\
1521 \xef%%n>\x06\x9008\xc4\xd8/&\xc6\tE0\rF\xff\xf0\xbc\x8c\xa4\x89i\x91Jqd\xcf$\
1522 \xd8D\xc1\x12\xf2\x16\xe3\xd0A\xe1r\x91\x99I\xc5\x01"\x11L\x93\x99v\xae\xb7`\
1523 \x18\x98I\x12\x16E\x85\xfa\x8b.\x9bG\xdf\x99/\xb3\x86\x13\xd9\x02\x8a\x0bC\
1524 \xd4\xd7\xd1\xf1\x845+\x99;\x9d\xbb\xcf(+\xe5Z\xf3\xd1[\xd9\xd1\xb8Y\x92a\
1525 \xbf\xcaVM*\x85\x02(^4\xc1\xe9ZN\xd4N&\xec\x18&\xf1T\xcf\xa4\x93\xc6V\xf6\
1526 \xeek\xdc\xe4WV4\x9dN\x81\xa5!AQ\xbc4\xac|\x9d\xea\xec\xf9\xee\x919\xb6iJ\
1527 \x1d,U\xe5;\xb2uu{(K\xde\xf7X>\xef\x8dJ\x93t\x12\x926T\xfa\xfb\xc3\xa6@[\x8b\
1528 VQ}n\xff=\xa6\xd2\xebv\xcd_\xdb\xe9\x05.\xf7\xaeR\xa3\x9f\x9b\x89\x1dr\xf8\'\
1529 \x1eyr\x00\\\xff\x01r\xb4\xfe\xcb\xc7\xdb.\x02\x00\x00\x00\x00IEND\xaeB`\x82\
1530 '
1531
1532 def getGBBitmap():
1533     return BitmapFromImage(getGBImage())
1534
1535 def getGBImage():
1536     stream = cStringIO.StringIO(getGBData())
1537     return ImageFromStream(stream)
1538
1539 index.append('GB')
1540 catalog['GB'] = ImageClass()
1541 catalog['GB'].getData = getGBData
1542 catalog['GB'].getImage = getGBImage
1543 catalog['GB'].getBitmap = getGBBitmap
1544
1545
1546 #----------------------------------------------------------------------
1547 def getGEData():
1548     return \
1549 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1550 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1551 \x00\x01\xb6IDAT(\x91E\x91Ok\x13Q\x14\xc5\xef{y\x99@\xa9\xb6\r\x01\x8dHW\xba\
1552 \x8e\xb4:\x8b\x82\x7fw.\xfc\x83\xda\x85\xf8\x01\\\xf9\r\x04\xc1U\xa1\x1b\xa1\
1553  \xf8\r\xdctQ\x05\x03-\xd6E\xd0\x12\x95jq\x1b\xc8"\x8dZ\x12\x13\x9cI2\xf3\
1554 \xe6\xddw\x8f\x8b\x89z\x16\x17.\xf7r\xe0\x9c\x9f\xea\xf5z\xf4W"\x92\xcf\xe0t\
1555 \x95<M:\x1d\x11\x11\x11f\xfew2DT\xa9T0\x1c\xf8\xaf_t\xed\x9cZ(\x03\x94\xad\
1556 \xad\x81\xdd\\\xb5\n\x00\xc3!\xbf{\xab.\x84T=\xd5j\xb5t\xee\xed\xbe\x1d\x0c>\
1557 \x7fp\x07\xfb\x00\x88\xe0\xbfw\xfd\xe1\xd4\xde\xee\x7f:\xda\xad\xdb\xbd\x06\
1558 \x111\x8b!"\x00\xc5\x8bW\xe6\x8f\xcd\x9a\xdar\xbe\x82\x1d\x9c\x03\x00\xc0\\\
1559 \xbeV.\x05&\\\x01 \xc2j\xfc\xe8a\xf1\xf6]\xfc\x8eH+d\x19\xbcG\x92\xf0\xde{8\
1560 \xa7\x97\x96\x11\x94\xe0=\x15\xb4L\xac\x9e?\xfe\xf3\xc9c\x93n\xbc\xd0\xe5\
1561 \x8a?\xec\x80\x19\x8e\xc99\x88\xc7\xcc\x0c<\xf3\xeb-\xa4\t\x1c\x8bsp\xae\xb0\
1562 \xb88\xea\x1c\x19\xf3`U\x9f\x0f\xe9\xccYRJ\xac\x85\xf7H&\xfc\xb1\tf}\xe9*\
1563 \x05\x01\x84\x0bJ\xfb\xd4\xea\x85rP\xdf\xa6n\xb7\xcb\xcc\xce\xb9x\xa7\x9ee\
1564 \x99\xb56M\xd3\xc1\xfd{\xbf\xee\xdc\x18\x8f\xc7\xa3\xd1(\x8e\xe3\x1f\x1b\xeb\
1565 Q\x14\xc5q\xdch4t^p\xfajs\xb8\xfdf\xb2\xf92\x0f\n\xf7?t\xfc\xfcY\x7fw\'Z\x7f\
1566 \n@D\x8c\x88\x00(-\x85s\xfd~)\\\xc9[V\'NRf\x95RD4{k\xd5$I\xf1\xfa\xcd\x1c\
1567 \x9cj\xb7\xdbS\x90BBS\xa8A\xad&D\xa3f\x93\x99\xf3\xbf\\D\xf4\x07\xd2\xb6Ns\
1568 \xf4W\xf2\xc7\x00\x00\x00\x00IEND\xaeB`\x82'
1569
1570 def getGEBitmap():
1571     return BitmapFromImage(getGEImage())
1572
1573 def getGEImage():
1574     stream = cStringIO.StringIO(getGEData())
1575     return ImageFromStream(stream)
1576
1577 index.append('GE')
1578 catalog['GE'] = ImageClass()
1579 catalog['GE'].getData = getGEData
1580 catalog['GE'].getImage = getGEImage
1581 catalog['GE'].getBitmap = getGEBitmap
1582
1583
1584 #----------------------------------------------------------------------
1585 def getGHData():
1586     return \
1587 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1588 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1589 \x00\x01\x17IDAT(\x91m\x8e=\x8aT\x01\x10\x84\xeb\xe9\x0b\x84\r\x8c\x97eL\xbc\
1590 \x817\xf0\x06\x82\x89\xac\x81\xe0f\x1e\xc0d#O\xa3\x91\xb0\xe39<\x83\x89\x1e@\
1591 Y\xd0\xa9\x9f.\x83\xb7\x83\xb3`S\x14MW}\xd0K\xf1o\xe6\xfe\xfe_-\x05p}\r\xa03\
1592 \x98AR\x07qm\xd8\x95z\xe2\xb7\xfb\xfd\n\x00h\xbf\xff@\x82\xa4\xd2\xe6w\xa2*\
1593 \x96\xac\xb4\xecv\x03\xac\x00:\xbd\xd7&k\xdfU\xc5R\x1b\x00i\x80u\x82e\t\xe0\
1594 \xd6\xa8\x0b\xdd\xfe\xd6\xa7\x8f\xa2ty\xc9\xb3Gl\xd5\xb2\x15\x16\xe1\x17\xb6\
1595 \x97\xd2\xaa5\xe0V7\x9f\xb9\xbf\xd1\xe1\x8f\x96\xf2\xea\xed\xd6\xde\x00\xcf\
1596 \xe0\x01\x80\xd6\xad\x8b-\xe0\xab\x97|r\xc1\xdd\xc5\xe1\xcdk\xb6\x87#@T3X\
1597 \x1f\xbe\xc7\xbb\x17\xfa\xf6\x93\x1e+d\xc4\xa1\x9eK\xd1\xb3/T\xc4P\x91\xc7O\
1598 \x1f\xfb\xeb\x07\xac0\x1c+\xd2h\x8b\x19jtt)\xf4\xc8\x13O@\xac 4>?;W\xe4\x897\
1599 r\xe4\xb1F\x8e]\'I\x93\t\x06\x0b\xae\x00\x02\x06x"\x9f\\|\xd4\x00\xc0_\x862e\
1600 e\xe4:\x93\x12\x00\x00\x00\x00IEND\xaeB`\x82'
1601
1602 def getGHBitmap():
1603     return BitmapFromImage(getGHImage())
1604
1605 def getGHImage():
1606     stream = cStringIO.StringIO(getGHData())
1607     return ImageFromStream(stream)
1608
1609 index.append('GH')
1610 catalog['GH'] = ImageClass()
1611 catalog['GH'].getData = getGHData
1612 catalog['GH'].getImage = getGHImage
1613 catalog['GH'].getBitmap = getGHBitmap
1614
1615
1616 #----------------------------------------------------------------------
1617 def getGLData():
1618     return \
1619 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1620 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1621 \x00\x01&IDAT(\x91eO\xbbj\x02Q\x10=WW\x0b\x0b\xc1\x85\x04\xac\x02\xfe\x82\
1622 \x8d\x1fbgmko\x9f\xb4\tZ$\x85\x8dZ\xf8\x1b\xa2$6\xd6\xb6"\x16\x8b\xdd\xee\
1623 \xe2\xdb;wN\x8a]\xc4\xc7\xe1\xc003\xe7\xcc\xc3\xc4q\x8c\x1b\xa8\x02P\xbd\x86\
1624 \'x\x00\x8a\xc5"\x00\x92\x00\x10\x86<\x9d\xe0\xfb\xcc\xe5\x92\xe2-\x82 \xf0\
1625 \x92\xc1$\xb1\xdba0\xe0|\x8e\xe3\x91\xbe\xcfF\x83\xb5\xda\xad\xda\x18#"\x99T\
1626 M\xa2\xdf\xe7d\x82\xed\x96\x87\x03W+\xbe\x7fp\xb1x\xd8\xa0\xaa\x99\xf4\xf6 \
1627 \xe0t\n+\xbc\\h-/\x17\xee\xf7\x1c\x8d\x9e\r\xc65\x9b\xa6^g\x14Q\x04\xaatJ\'t\
1628 \xee\x91"\xa6T\x8a\xdbm\x0f\xbd\x1e\x0b\x05\xaa\xf2\xeb\x13\xbc\xffr<f\xab\
1629 \x95.\xb4\xd6T*\x1a\x86\x19\x05h-\x97K\xfc\xfe\xdd\xa9\xad\xe5pxUC\x84"\x02x\
1630 \ndEx>\xa3\xd3\xa1*\xabUf\xb3\xdcl\xd8\xedr6K\rb!\x0e\xce!1d\xac\xa0\\\xa6\
1631 \xb5\xf8\xfe\xc1\xeb\x0b\xf2y\xb3^#\x8a\xf0\xf6\x06\x11\x88\xc0\xb9\x84\n\
1632 \x98=\xa07\xc4}\xfa\xd0\x02\xf0\x0f\x18\x8a[Jp\xcda\xd0\x00\x00\x00\x00IEND\
1633 \xaeB`\x82'
1634
1635 def getGLBitmap():
1636     return BitmapFromImage(getGLImage())
1637
1638 def getGLImage():
1639     stream = cStringIO.StringIO(getGLData())
1640     return ImageFromStream(stream)
1641
1642 index.append('GL')
1643 catalog['GL'] = ImageClass()
1644 catalog['GL'].getData = getGLData
1645 catalog['GL'].getImage = getGLImage
1646 catalog['GL'].getBitmap = getGLBitmap
1647
1648
1649 #----------------------------------------------------------------------
1650 def getGRData():
1651     return \
1652 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1653 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1654 \x00\x01NIDAT(\x91e\x91?K\x03A\x10\xc5\xdf]N4b\xe0\x08\x11\x1b\xd3X\xe9\x81]\
1655 D\xc1B\x10\xc9g\x11\xf1;X\x0b\x16\x16\xe2\xa7\x10D\x05\x8btF\x05\x11\xc5\x14\
1656 \x01I\xc4\xa8\x87H\n\xf1\x0f\x045\xc7\xee{\x16{\x89\x01afx\xb3\x0co\x7f;\xeb\
1657 \xe5\x96\xce\x01\\\xec\x86\x00J\xabo\xa0\xf7\x9dX$DB$&\xad?\x06?DB\xc8\x04\
1658 \x00\x96Ka\x14E\x92V\xe6n!\xedmNK\x10\x00\tr)I\x14\x1e\xe3\x17/\x8e\xe3b\xb1\
1659 (\t\x00\x00I\xe77\xef\x14(\x91\x92D\xa6:;\xe2\x9fV\x9e\x037\xd4\x9f\x06P\xbb\
1660 \xfb\xb6\xa4\xb1\xb2\x96\xc6\xca\x18\x19KZ\xe5\xc3`c\xa7\xee\r/\x9e\x96\xe7\
1661 \xf3\x07[3\x92\x96\xd7\xea\xa4\x8e\xb7\xa3\x94\x02)\x8a\xbb\xc9\xf7\xfdf3\
1662 \x0eL\xd2ct\x0cTy\xbdNGB\xa5!Q\x1a\xcb\x06\xb5\xea\xbd\xd7n\xbf\x16\n\xe1\
1663 \x80\xe1\xa0`?\x01\xf9\xbe\xdfj=\x05\xfb\xd5\xce\xc2l\xe6\xabK\xf5\x9c\xe4\
1664 \xbc{0\x14\x9c\x18\x1d\xc9\x9cU:\xc1\xc9U{j2\xf7\xd1I\xac\x95\xa5\xace_\xd0\
1665 \xb5\xa4\xa5,\x95\xcf\rm\x1e6\xbc\xc6\xc3\xe7x~X\x12\xdc\xfa IH\x1f\xfaG\x08\
1666 \x91\xc2\xe5u\xd3\xc3\xc4Q\xfa\x91]\x02\xe6_\x10p\xe7p\xf5\x17\xeb\x1bkP\xc4\
1667 G\x864\x00\x00\x00\x00IEND\xaeB`\x82'
1668
1669 def getGRBitmap():
1670     return BitmapFromImage(getGRImage())
1671
1672 def getGRImage():
1673     stream = cStringIO.StringIO(getGRData())
1674     return ImageFromStream(stream)
1675
1676 index.append('GR')
1677 catalog['GR'] = ImageClass()
1678 catalog['GR'].getData = getGRData
1679 catalog['GR'].getImage = getGRImage
1680 catalog['GR'].getBitmap = getGRBitmap
1681
1682
1683 #----------------------------------------------------------------------
1684 def getGTData():
1685     return \
1686 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1687 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1688 \x00\x01\x1bIDAT(\x91e\x8f1jVQ\x14\x84\xbf\x9bw\x8b\xbf\x90` \xc4\xc2\xc22\
1689 \xcb\xb0\xca\x1e,\xec\x93\xca\xde\x15\xb8\x01W\xe0"\xdc\x84k\xb0\xb2\x08\x84\
1690  I\x88\x8f\xc7\xbdsf,^@\xf0?\xcd\xc0\xe1;3s\xdar\x9d\xda\x000\xac\xfe\xf5\
1691 \xf5\xe1\xd0m\x1b\xb0\xfd\xb4\xfa\xf2\xc3kdd6s\xa0\xd73_>\x02\x943\xd5\xde\
1692 \x9c\x9f-\'@\x92\x00\xa737\x9fbG\x159\xdf>?w:\xc0\xedcTl\xc2\xc9\xb2\xe3I\
1693 \x129?\xefbgV\xde\x9e5\xe4\x8e\xb1#SF\x95\xe4\x1f\xbd\xcfP\xec\xc8Q\xc1\xe6\
1694 \x8e\\n*\xcaQ\xfdO\xc7\x19\x95T\xe4\xcc\x82AGT\xa8\xcat\xa6\x8e\x0e\x92\xa9\
1695 \x97\x1f\xa6\x1a\xe5\x8e\xa8\x17\x83\xcc\xa3\x04;C\xc9^\xc9\x01wd\xa5\xcd\
1696 \xca\x14S\xc7\x01\xd9\x97*\xaa\x02\xea\x0cK\xcbT\xa6\x18u\x84\x93\xa1\x90\
1697 \xc8\xa8\x00:\xab\xa7O.N\x99\x95m\xd0\x1a@\xdb\x05\x96\xc6\xbbsH\xb3S\x01\
1698 \xdc\xb8\xfa\xc3o3\xccjV\xff\xf8~\xf7\xea\x80$\xdb\xb6\xef\x9ft\xf5\xfe\x02\
1699 \x0c\xde-\xfe\x02\xd5\x00s\xcdr\x8cr\x81\x00\x00\x00\x00IEND\xaeB`\x82'
1700
1701 def getGTBitmap():
1702     return BitmapFromImage(getGTImage())
1703
1704 def getGTImage():
1705     stream = cStringIO.StringIO(getGTData())
1706     return ImageFromStream(stream)
1707
1708 index.append('GT')
1709 catalog['GT'] = ImageClass()
1710 catalog['GT'].getData = getGTData
1711 catalog['GT'].getImage = getGTImage
1712 catalog['GT'].getBitmap = getGTBitmap
1713
1714
1715 #----------------------------------------------------------------------
1716 def getHKData():
1717     return \
1718 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1719 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1720 \x00\x01PIDAT(\x91U\x91\xb1.\x84q\x10\xc4\xe7\xfb\xdfG|\x1c"\xa2P\xd0\xea\
1721 \x14J:\x8fB\xe7\t$<\x85\xc2S\x88\xe2\x94\x1a\x12/\xa1\xe2rDHD\xf8\x8e\xb0\
1722 \xb3\xbb\xa3\xb8#l&\x93-&\x99\xdd\xfc\xaag 1\x9e\xfc\xf1\xbfr\x00\x80\x03\t\
1723 \x14\xa0v\xa0{p\x00\x00\x99\xcaT\x04<\x14\x8e\x08\x91"\xe5\xfe\xeb\x83^\xaf.\
1724 \x00\xa0\xbc\xbbW\x84"@*\xa2\xbb\xb9\xa5\x99\xe9\xb7\x93\x934\x8a&3\x91ee\
1725 \x05@\x01\x80\xd48\x1dQJ)\x9d\x8evw\xb4\xb66\xb5\xb8X\x15\xa4\xd9H"\x1d\xa8\
1726 \x13P\x84\xdc\xe1^UUsx\xa8\x97\x17\xdd\xdcj\xaa\xe9\x1c\x1d\xcd<<\xbc\xef\
1727 \xed\xd9p8:/\x81\x1a\x80<D\xc2=\x19\xba\xbe\xd6\xf6\xb6zgj\x1ae\xe8\xfc<?>\
1728 \xd2\x0c\xa4\xdc\xf3\xa7\xc1\xe1.\x9a\xe8\xaf\xc7\xc7\xb3\x8066\x94\xa9\xe9\
1729 \xa6==e\xdb\x8e\x7f \x1d(\t\x80\x94\x99\xe8i69?\xaf\xf5u\x99\xe9\xf2BM3\xd1\
1730 \xed\x8e\xd2r\xcf\xdf\x06\xb8\x8bLR\xe4\xd7\xe3c\xb5\xbf\xff\xd9\xef[\xdb\
1731 \xce]]\r\x07\x03\x99\xc1\x99\x1e%"G\x1c\x92^-/\x17R\x1er~\x92\xb9\xb4\xd4YX\
1732 \x18>=\xd5\xab\xabp\xcf\x88\x12\xa1\x08\x07\xaa>`\xff\xb9\xfe]\xfc?\xfbI\xe0\
1733 \x1b\xf2\x8b=\xe6c\xc4\xda\x04\x00\x00\x00\x00IEND\xaeB`\x82'
1734
1735 def getHKBitmap():
1736     return BitmapFromImage(getHKImage())
1737
1738 def getHKImage():
1739     stream = cStringIO.StringIO(getHKData())
1740     return ImageFromStream(stream)
1741
1742 index.append('HK')
1743 catalog['HK'] = ImageClass()
1744 catalog['HK'].getData = getHKData
1745 catalog['HK'].getImage = getHKImage
1746 catalog['HK'].getBitmap = getHKBitmap
1747
1748
1749 #----------------------------------------------------------------------
1750 def getHNData():
1751     return \
1752 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1753 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1754 \x00\x01bIDAT(\x91m\x911k\x14q\x14\xc4g\xe3\x12s^\x1f#\x18E\x08\xd8\xe6\x0b(\
1755 \xc8\x81b:\x05\xbb\xd4~\t\x0b\x11\x8b\x83@P\xb4H\xa1\xd8\x88\xa0B \x9d \xf6\
1756 \x87\xa5\xa5\x8d\x16F.\nZ\x98\xdd\xb0\xfb\x7f\xf3f,\x96\xeb\xf2\xf8\xf1\x98\
1757 \xc7\xf0\x8aa*\\~\x83\x7f\xc40\x14\nA!\x05\xf04P\xe3oy\xb4s\r\x80\x04Y\x99H)\
1758 i\xa6I3\xc5\x14\xa9\xa0\x98~\xb7\xfb\xbaFQ\t\x1d\xfe\xea3\x95\x89\x85\xed\
1759 \xa0\x06JQaF\xd1\xfa\x85\x11\xd0\xd5\xd3\xa7\x9b\xb7o\xac\x9dti;e\xa7\x05[\
1760 \xce\x81pB\x92%\x8dG5\x9b\xeb\x98\xcf\xe7\x92$e\xe6q\x13{o\xbfGD\xdf\x97\xae\
1761 \xef\xbb\xae\x9b\xbe\xf8\xfa\xfb\xcfq\xdb\xb6M\xd3\xb4m;\x9b\xcd\x96\x86\xb4\
1762 \xb6m\x9f]\xc6\x9d\xc9y\xdb\xfb\x9f\x8e\xde\x7f8\xb2\xbd\xbd\xb56Z\xae\x06\
1763 \xd7\x80\xa4%I\x8b\xdb}\xd1\xcb\xfd\x1f\xb6\xefNV\xef\xddZ\xb5\xfd\xea\xe0g\
1764 \xd7\xe7\xc27\xc9\xea\xf1\xf3\xcf[\x93\xab\xed\t%\xa5L\np\xca\x92\x94f\xca\
1765 \x86$\xc9\xe3s\xf5\xf4\xd9\xc7\n\xd8\xbd\xff\xf0\xe6\xb7\xc36B\xc1,t)\x19\
1766 \x91\x85\x8eP\xa1#\xc8\x14\xe9\x8dK\xe3/\x07Oj\x80gj\\\xb98\n\x8a\x14\xe9A\
1767 \x04\xc5\x14\xd3\x99\x1e\x1e,\x03\xa8\x80\x07\xc0\xca\xa2\xc8r\x9a\x18Z\x1f\
1768 \xf6\xca\x7f\xd9\xbdt\xc3\xb4K\xeei\x00\x00\x00\x00IEND\xaeB`\x82'
1769
1770 def getHNBitmap():
1771     return BitmapFromImage(getHNImage())
1772
1773 def getHNImage():
1774     stream = cStringIO.StringIO(getHNData())
1775     return ImageFromStream(stream)
1776
1777 index.append('HN')
1778 catalog['HN'] = ImageClass()
1779 catalog['HN'].getData = getHNData
1780 catalog['HN'].getImage = getHNImage
1781 catalog['HN'].getBitmap = getHNBitmap
1782
1783
1784 #----------------------------------------------------------------------
1785 def getHRData():
1786     return \
1787 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1788 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1789 \x00\x01lIDAT(\x91m\x911hSq\x18\xc4\xef\xc5T;t\x11Dp\x08\x8a \x94\xee\xed\
1790 \xdc\x0e]\xc4U\x04\x17\x11:\xe9,\x08\x05\x1d\x0b\xa5\x82\xd0\xd9\xc5\xa1\xd8\
1791 \xc9\xb9\x9b\xe0\x92!CG\x07\xb7\xf8\xc8\x98\xe4\xe5\xfd\xdfK\xfe\xdfw\xf79\
1792 \xa4\x8d\x08=\x8e\xe3\x86\xdfMW\x04\xfeI\xff\xf7\x1b]\x04\x80\xc3C\x00!\x01@\
1793 \xa7\x13\n\xd1\x83*,\xc3,\xdc\xe3:\xeb\xf3\xf3.\x00 \xe2O\t\x12d\x98\xbd{~\
1794 \xe2\x0f\xc3\x7f\x87?\xd2\xe9\xfb\xd7a9r\x0e\xb3\xa2\xd7\x13\xd0\x01\x10\x8a\
1795 \x15m\xe4\xf1\xd7\xb7\x9f\xd6\xa7\x9f\xbf\x1c\x9c\xaeO\xcc\x16\x91\xf3\x95\
1796 \xcd\x04\x80\xa4$I$\xe9l\xdb\xd6./\xf3\xde\xdeb0\x98\xef\xecTU\xd54MJ\xa9\
1797 \xae\xeb\x94\xd2h4\xba\x1a\x90twwo\x9a&\xef\xee.\xe9\xb6\xdf\x9fL\xa7Kz6\x9b\
1798 \xd5)\x95e\t\x92K\xda\xdc\xcc,\xa5\xb4\x18\x0c\xe6\xdb\xdbm\xbf\xdflm\x8d\
1799 \xc7\xe3%]UU]\xd7\xc3\xe1\xb0\xc0\x8b\x9fG\xaf\x1e\x97\x93\x851\x9c2j6\xfcu\
1800 \xf6\xfdC\x98={\xfa\xf1\xf6\x83M\xa3\\rF\xef\xee\x9doo~t\x91\xdd%\xa3V\x83[\
1801 \xf7\x9f\xbc<83j\x8d2\xca\\\x1e\xe1\x0c*\x00u\x91\xe5\x8a{\x1bkN\x912\x81\
1802 \x943H\x99\x82\x14#\x9c\xa1\x08W\x00*\xb0\x7f\x01\x17\xe6\x8e\xec\xc8Bv\xcc\
1803 \xafKv\xb8#\x0b\\\x1d\x8d\xbf\x12\xd3w\x1d*\x1e\x9e\xc6\x00\x00\x00\x00IEND\
1804 \xaeB`\x82'
1805
1806 def getHRBitmap():
1807     return BitmapFromImage(getHRImage())
1808
1809 def getHRImage():
1810     stream = cStringIO.StringIO(getHRData())
1811     return ImageFromStream(stream)
1812
1813 index.append('HR')
1814 catalog['HR'] = ImageClass()
1815 catalog['HR'].getData = getHRData
1816 catalog['HR'].getImage = getHRImage
1817 catalog['HR'].getBitmap = getHRBitmap
1818
1819
1820 #----------------------------------------------------------------------
1821 def getHUData():
1822     return \
1823 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1824 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1825 \x00\x00\xecIDAT(\x91}\x8e)RCQ\x10E\xef\xab\xfa8\x14."\x06\x96\xc1"\xd8\x04*\
1826 \n\x9f]e\x1f\xc9\x16b\xc0"\xa2R}\x87F\xfc|f\xb8\xa2\xebt\xd5\xe9a\xec\xf1%\
1827 \x02\x00d\x01-<W\x01\x13\x80\xf5v\x0b\xa0\x93N`C\x8e\x05)R\x93-5\x19)\xe4a\
1828 \xb7\x9b\x00\x00\xcd\xe7\x97\xb6a7\x19\x1bd\xc8&S\x0c\xab\xabB^\xad\xd7\x99/\
1829 t\xfa\xb3\xddU-u1\xac\xb0\xba\x98\xaay\xbe\x80a{\x8c\x01\xa0\xbb\xd1h\xf4_\
1830 \x19c\x9cN\xa7\xf9\xa5\x8b\xf5\x0e\xbf\x06c$\x99>\xa4\xff\xf7w\x8f\xee$\x03\
1831 \x0f\xd8<n\x8e\xafGYt\x95X.\x9a4\xcb\xc5\xa5\x95uws\xbb\x7f:L8C\x12M\xea"\
1832 \x95\xeab\x9be\xd2%S\xb6\xda\x00&\x14\x18\xad\xaeW\x0c%+\xa4\xc9P\x12\x9b\
1833 \xb2\x14Y6l\x1b\xc0\xc0=P@\x01\xe7\x1fP@\xe3[\xde\x00"\xe4m\x06\x8e\x93\xa5\
1834 \x03\x00\x00\x00\x00IEND\xaeB`\x82'
1835
1836 def getHUBitmap():
1837     return BitmapFromImage(getHUImage())
1838
1839 def getHUImage():
1840     stream = cStringIO.StringIO(getHUData())
1841     return ImageFromStream(stream)
1842
1843 index.append('HU')
1844 catalog['HU'] = ImageClass()
1845 catalog['HU'].getData = getHUData
1846 catalog['HU'].getImage = getHUImage
1847 catalog['HU'].getBitmap = getHUBitmap
1848
1849
1850 #----------------------------------------------------------------------
1851 def getIDData():
1852     return \
1853 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1854 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1855 \x00\x00\xf6IDAT(\x91}\x8e;J\x04Q\x10E\xef\xeb\xee\xc0@a\xc6\xc0@\xb7"\xb8\
1856 \x1aC\xd7a\xe6\x02\x0c\xdd\x8f\xb8\x00\x03C\xcd\x9a\x11\x95\xe1\xd5\xfd\x18\
1857 \xf4\x0c\xa80\x1e*(\xa8{\xaa\xaa\xbd\xacG\xbc\x0b\x00\x00\x0b\x00\x0c\x18\
1858 \x00\xc0}\xef\x1f\xfd\x84Y\xa7w\xb7\x00b\xc3\x8e\x149"\xcc\x94,\x86\x0c+\xc5\
1859 \x90\xcf\xf7\x0f\x13F\x00\xe0\xdb+\xa4H!w\xa5r1Uf\xa5*\xbd\x8f\xe7\x17\x06&\
1860 \x08\x91\x97\xb4\xc9\x90`\x85e2EW\x0f\xcb\xbd\xc2j$\x81\x89\x80\xbf>\xf5\xf1\
1861 \x1e\n\xbb}LuW\x85\xe5\xaaT\xb9w\xb3\xda\xf1I\x07\xa6\xd5\xcd\xf5\xd1\xe5\
1862 \x956\x9bH\xb1\xe2\xe51\xc5\ne1\xcbqi\\\xad\xcf\x9e\x1e\x9b$\x00I\x82 \xc8a\
1863 \x86a\x98\xe7y\xb2\xddZK\xb2\xd3\x0e\xb0LI\x0e\xb6\xff\x8f\xfe\xd1&\xdb\xc30\
1864 ,\x0e\xf6\xb4\xd6\xf0\x8b\x06\x04\x80\xed\xc9\xf6v\xbb\xf5\x02\x0c\xc3\x07X\
1865 \xd4o\xffbv\xee\x97/\x0e>\x00\x00\x00\x00IEND\xaeB`\x82'
1866
1867 def getIDBitmap():
1868     return BitmapFromImage(getIDImage())
1869
1870 def getIDImage():
1871     stream = cStringIO.StringIO(getIDData())
1872     return ImageFromStream(stream)
1873
1874 index.append('ID')
1875 catalog['ID'] = ImageClass()
1876 catalog['ID'].getData = getIDData
1877 catalog['ID'].getImage = getIDImage
1878 catalog['ID'].getBitmap = getIDBitmap
1879
1880
1881 #----------------------------------------------------------------------
1882 def getIEData():
1883     return \
1884 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1885 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1886 \x00\x01\x14IDAT(\x91m\x8f=\x8aTa\x14D\xcf\xf7x\x828L\xe4\xcf0\x83&\x82\x1b\
1887 \x11\x8c\\\x80\x89\xa1\xa9\x99\x820\xabp+&\xb3\x18\x93\t\xec@0\xd2\x16\x1f\
1888 \xdf\xad[e\xd0\x8d\x81=\x87\x1b\xd6)\xea\x0e>\xc3\x06\x80A\xec\xde\xed\x16\
1889 \x16\xc0\x07\xb4=z\xf9\xc2\xc6\x13O|\x9f\x95=\xd7\xaf\xae\x8f\x89\xf8\xe2\
1890 \xf1\xc5\x18\x0b$\t\x10+\x9f\xde&\x15+]\xfb\xf7_VV \xdf~\xef\xda\xdd\xdd{\
1891 \xed\xcf\xef\x9d\xe7\x1f\x7f~\xe5\xfb\xd7d\xa6j<|fX1v\xda-\xb7\xbar\x8afz&E\
1892 \x97a\x05\x9aV$K\xd6I\xdc\xa9\x19\xcf\xb8\xe8\x02V\x84\xdc\xd5\xa5\xbeSH4\
1893 \x93\x19\x15\x92\x0fB[\xb2\xa6\xa7\xfaD\xb0\xd3\xc7I\xe38ITj\xf6T\xabz:\xfe\
1894 \xdf\xa9\x19\x8aVZ:NjU\xd7\xe1\xee\xf8A3\x14n\xdc\xc0\xcaFY\x97g\x97\xd5%\
1895 \xf52\x16`\x8c\xc1\x81e\xe5\xc9sh\xbaq\x1b\x06\x1f\xe1'\x086\xd8\xb8\xf9ps\
1896 \xf5\xe0\xca\xb6$\xdb\xfaq\xfb\xf4\xf5\x1b\x83\x8f\x05\xfc\x05J\xc3r\xa9\x15\
1897 \x84\x03\\\x00\x00\x00\x00IEND\xaeB`\x82"
1898
1899 def getIEBitmap():
1900     return BitmapFromImage(getIEImage())
1901
1902 def getIEImage():
1903     stream = cStringIO.StringIO(getIEData())
1904     return ImageFromStream(stream)
1905
1906 index.append('IE')
1907 catalog['IE'] = ImageClass()
1908 catalog['IE'].getData = getIEData
1909 catalog['IE'].getImage = getIEImage
1910 catalog['IE'].getBitmap = getIEBitmap
1911
1912
1913 #----------------------------------------------------------------------
1914 def getILData():
1915     return \
1916 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1917 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1918 \x00\x01\rIDAT(\x91m\x91\xb1J\x03Q\x10E\xe7\x85\x04\xc1\xc6n\xb1\x10\xec\xfc\
1919 \tK\x05\xbb\x90\xcaB\xacD\x10A\x02"vi\x04\x1b\x11\x05\xad,\x14\x1b\x05\xed\
1920 \xd2h\xeb_\x84@J\xab\xf7\r;s\x8f\xc5\x86\xdd\x8d:\xd5}\xcc\xb9\xdc\x99y)\xe7\
1921 l\xad\x92$\xa9\x16\x92\xdc\xdd\xcc\xdc\xbdz\xa6\xa5\x9d|?,\xcc,\x00,d\x92\
1922 \x85\x88 d\x1e\xb8\x08\'\x84;\xd7G\xd3\x94s.\x8a\x02\xa8\x12*\xc1\x7f\x95R\
1923 \x9aL&\xdd\x1aj\xd3\xb7/\x08N\xf7\x16\x0c\xd5\x9c\xddj\xe29\x8d=\x7f0\xfdf\
1924 \xa5\xc7j\x87\xe1\x1d\x1bk\x1c\x0f\x1a\x83\xbbwj\x1a\xc0\x18l\xe2%\'\xbb\xf4\
1925 \xfb\x94%\xfb[\x0b\x11\x92:\x92j\x1ax\xff\xa2t\xc6cn^)\x83\xa7\xcf\x16\x0f\
1926 \xee\xde\xad\rU\xcea\x1f\xe0\xea\x91\xe5\x1e\x0fgD\xd0\xee6;\xfc:\xce\xf9A}\
1927 \x99\xc60_z}[\x97\x17\xb8,\x1c\x97\xb9\x9b\x87E$\x0fsY\x84\x85,"\x85\x10\xf6\
1928 6R\x9a\xcdf\xed\x8f\xfc+\xdaef?)\x08y\x12\x05 \xf8T\x00\x00\x00\x00IEND\xaeB\
1929 `\x82'
1930
1931 def getILBitmap():
1932     return BitmapFromImage(getILImage())
1933
1934 def getILImage():
1935     stream = cStringIO.StringIO(getILData())
1936     return ImageFromStream(stream)
1937
1938 index.append('IL')
1939 catalog['IL'] = ImageClass()
1940 catalog['IL'].getData = getILData
1941 catalog['IL'].getImage = getILImage
1942 catalog['IL'].getBitmap = getILBitmap
1943
1944
1945 #----------------------------------------------------------------------
1946 def getINData():
1947     return \
1948 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1949 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1950 \x00\x01@IDAT(\x91MM\xbdjTa\x10=\xdf\xf5\xa2\x18\x8b\xf8\xb3\xa601\x881 \x16\
1951 \x8a\x82\xaf!>\x82\xe0#XZ\xa5\xcb\x93\x98\xde&`\x93F\xb0\x11;\xab,v[Y\xc8&n\
1952 \xb1w\xce\x8f\xc5\xdd]3\x9c\x19f\xce\x999\xd3r\x86MxL\x03\x86\t\x1b\x1e\x1b\
1953 \xaeG\xa2\x07\x80\xc3\x8f\x00\x02\xb7\x18Q \x98-\xbcfv\xa8\x98q%L\xea\xef\
1954 \xd7\xcf=\x00 \xa9\x19"XI!\x8a+\xa9u\x1d\xe2!\xaev\xe3\xa1\x89\xde;\xaf\xdb\
1955 \xcdg\xe8w\x12\'B4\xfd}\xf7\xfbt_\xd6\xabG\xe7\x87\x93Y\xc2\x98\x0e[\x7f\xdf\
1956 \x0fN[I]k\t\x92\x8c\xdf>\x9d\xfeZ^,^<\xbd\xf7cz\xf9\xee\xcdc\'q\x9ct\xad\xfd\
1957 \x99_t\x1d\x80\x00\xc9\x06\x8b\xc5\xf2`w\xeb\xcb\xd9\xf9\xe5b\x99$NF\t\x80\
1958 \xdd\x8d\xae@\xd0\x02$\xc9\xf3\x83;\xdf~\xcey}\xeb\xe5\x93\xdbIV\xea\nn\xf8\
1959 \x80\xe3\xb7\xc7\xb3\xf9\x8c&U%\x96\x8bb\xa9h\x96\x8a"E\x9a{\xdb{\'G\'=\x88\
1960 \x91\xda\xec\xfd_57\x97\xb4da@\x8f\x014\'\xb7&\xa3\xcd\xaa\x9a4eIb(I\x91,\
1961 \x18\r\xef\x81\x01 0\\\x01\xaf0\\\xc3\x00\xf0\x0f\xfa<M\x16\xb29\x92\xc3\x00\
1962 \x00\x00\x00IEND\xaeB`\x82'
1963
1964 def getINBitmap():
1965     return BitmapFromImage(getINImage())
1966
1967 def getINImage():
1968     stream = cStringIO.StringIO(getINData())
1969     return ImageFromStream(stream)
1970
1971 index.append('IN')
1972 catalog['IN'] = ImageClass()
1973 catalog['IN'].getData = getINData
1974 catalog['IN'].getImage = getINImage
1975 catalog['IN'].getBitmap = getINBitmap
1976
1977
1978 #----------------------------------------------------------------------
1979 def getIQData():
1980     return \
1981 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
1982 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
1983 \x00\x01\\IDAT(\x91\x9d\x8e\xb1j\x93a\x14\x86\xdfO\x7fl)\xea &!\xd4\x80B\x16\
1984 ]\x02\xa5\x1d\xf4\n\xf4\x02\xa4\xeded\xee\x9e\xab(\x1du/B\xc4M\xd4\xe8\x9a\
1985 \xba(-\x01\xc5\x1a\xc1Vl\x9a4\xc9\xf7\x9es^\x87\xdf\xa2B'\x1f^\x1e\x9e\xe5\
1986 \xc0I\xc2\x1f\xe2\xdf\xbepI\x00\xb6\xb6\x00(\x02\x11p\x979\xdcd\x063\x91\xfa\
1987 \xcb\xe3\xdd\xdd\x02\x00 }9\x84;\xdcE\x96\xfe\xbdL1+g\x91\xa9\xd1\x08\xa0\
1988 \xc0\xda\x9a\xee\xdeC\xa5\x06A\x96\xe1!7\xb9d\x94Q\xee\xa2)By\x8eJ%\xba]\xb8\
1989 {D\xcc\xc3\x9e}\xea\x9a\xf9\xcc\xec\x8c\xf9\xe5\xe1\xebW_\xdfLf\xb3\xe3\xe9\
1990 \xe8\xc7\xd9\xc9\xf6\xfb\x9d\xd1x<\x99L\x86\xc3a\xf9\x12^|~\xfe\xe1\xe7\xc7\
1991 \xf1|T]Z\xae.\xdex\xf7\xedmq\xe9\xf2BZ<\x9d\x9f\xee\x1d\xef\x1d\x8c\xf6\x15\
1992 \xdalnDD\x01@\xd2\xa3[\x0f\xb3\xe7\x07\xf5\xfb\xee~\xed\xca\xd5\xd5\xea\x8a\
1993 \x84\xdb\xd7\x1b\x92Vn\xb6\x9e\xec?]\xbf\xf3\x18RD\xa4V\xab\xd5n\xb7\x8f\xbe\
1994 \x1f%%\x92\xe6F2<h\xa4\xd1\xcdiL\x91\xa6\x9c\xd6j\xb5N\xa7S\xf4\xfb\xfd^\xaf\
1995 7\x18\x0cH\x92\xcc9\xe7\x9c\xcb Y\x96\x19\xcd\xbc\xd9l\x02(\x00\x90V\xaf\xd7\
1996 I\x9a\xb9YyH3+mf~\x0e\xfe\x83_x\x8eB~M9z*\x00\x00\x00\x00IEND\xaeB`\x82"
1997
1998 def getIQBitmap():
1999     return BitmapFromImage(getIQImage())
2000
2001 def getIQImage():
2002     stream = cStringIO.StringIO(getIQData())
2003     return ImageFromStream(stream)
2004
2005 index.append('IQ')
2006 catalog['IQ'] = ImageClass()
2007 catalog['IQ'].getData = getIQData
2008 catalog['IQ'].getImage = getIQImage
2009 catalog['IQ'].getBitmap = getIQBitmap
2010
2011
2012 #----------------------------------------------------------------------
2013 def getIRData():
2014     return \
2015 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2016 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2017 \x00\x01UIDAT(\x91]O\xbbNBQ\x10\x9cs9\x01\x95\x98\xa8\x05\x85\x08\rT\x16\xfa\
2018 \x01\xd6\xfe\x82\x85\x7f@Go\xfc\x07\xec,\x8d\x85\xb1\xb6\xc1XjCALH\xecL\xf0\
2019 \x11\xac\xd4\x10\x11\x82\xf7\xec\xd9\x1d\x0b\x1eA\'\x93\xd9\xd7\xec&\xebp\
2020 \x02\xfc`\n\x03\xe2L\x17\x19f\xea\xe11\xc4\xd1\xfe\x11\x0033\x98\x9aFSe\x8c6\
2021 \xa1\x88\xc6H\x11\x8d\xa2ruz\xe5\xe1\xe1\xe0z\xa37\xa3\xceM\x91\x1aT\xa2J\
2022 \xb0 *A\x83h(\xad\x96\x91\xc07\x0f\x9b\x1b\xd9\x8d\xb5\xecZo\xd4\xdb\\\xd9|\
2023 \xf9~\xd9\xca\x97\x9e\xbe\x9f\xb6V\x8a\xcf\xa3\xd7\xd2r\xb1;\xe8\x96\xf3\xe5\
2024 \xc7\xaf\xc7\xed\xf5\xed\xe1\xc1\xd0\xa9\xaas\x0e\x00I\x10\x049NywK#\xf7\xf6\
2025 \xb8\x94\xe5\x0c\xce\xb9\xc1`\x90L\xbe\x9d\xf6&\xf1\xf2\x82\x1f\xef\xccz\x9e\
2026 \x9fq\x11\x80\x999U\x9d.L\xef\x93\xaal4(\xc2z\x9d\x99\xcc\xdc\x9f$I\xbf\xdf\
2027 \xcf\x1c\xe7r\xa8V\xd9n#\r\xect\x98\xa6\xect\xb8\xb3K\xefi\xc6V\x8bi\xcaV\
2028 \x0b\xe31\x1e\x1e\x867\xd7.\x052\xb5\x9au\xbb\x08\x81"\x14\xe1<Y\xc8\xa1\xea\
2029 *\x95\xcf\xfb{o@\xf2\x93\xa2P\xa0\x08\xa2"\nD\x9c\x08b\xc4Dc\x84*T\x11\x82\
2030 \x01n\x04\xd8\x02\xf1\xb7\xfc7\x02\xf0\x0b\xcf{C\x1ej\x83A\xa2\x00\x00\x00\
2031 \x00IEND\xaeB`\x82'
2032
2033 def getIRBitmap():
2034     return BitmapFromImage(getIRImage())
2035
2036 def getIRImage():
2037     stream = cStringIO.StringIO(getIRData())
2038     return ImageFromStream(stream)
2039
2040 index.append('IR')
2041 catalog['IR'] = ImageClass()
2042 catalog['IR'].getData = getIRData
2043 catalog['IR'].getImage = getIRImage
2044 catalog['IR'].getBitmap = getIRBitmap
2045
2046
2047 #----------------------------------------------------------------------
2048 def getISData():
2049     return \
2050 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2051 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2052 \x00\x01aIDAT(\x91mQ\xb1j\xd4q\x18\xcb\xef\xfe\x7f\x87\xd6\xa9\xedU\xe1(\xb4\
2053 8\xba\xf8\x00\x05qW7\xc1\x17\xf0\t\\\xbc\x1e\x05\x11\'\x07A\x1c\x047\x11\x07\
2054 q\x13\'\x07\xfb\x08\x0e\xe2&8\xf4\x06\xd1\xb6\x1c\x1c\x14\x8e\xefK\xbe8\x9c\
2055 \xe7\xd4\x0cYB\x12B\x1an\xbc\xc6\n\xfa\xfa\xe0g\xd7]\x93\xba\xbd\x97\x08"\
2056 \x88\x05\x11\x84\x08\x04@ z\x00\xcf\x0e\xf6\x01T\xb9\xb56\x9c\x1c\x00\xed\
2057 \xf0\xc9M\xd1,\x93EY\xa5d\xa5\xea\xcd\xf8]\x0f\x00\xf0\xaf\xb3\x85\xaa\x00\
2058 \xf0\xf8\x18\xf0\xf4\xf7y\xd2\xa9"\x15\xac\x94\xc8\x1am\xad\x01\xecQU\x82\
2059 \xaa$\xdb6\xd3v\xb0H\xa7\x94\xac\xa4\x82%\x892\x10MRk\r\x80m\x18\xa7\xf7\xef\
2060 m\xbe\xff\xe0\x8b\xd0Z\x9b\xcf\xe7\xed\x070\x1c?\xe2tj\xd2\x99\x95\x89LgV\
2061 \x86#+\xb3"\x9c,\xc6\xa5\xdd\xbdo_\x8e\x9a\xa4e\xbca\x18\xa7woo~\xfcta\xc3`0\
2062 \x98\xcdf}\xb7\xf3b\xf2\xf4\xd6\xf4\xcfyRo\xc7\xfb\x15i\xfb\xce\xe4(\xb9\x1c\
2063 P\xc9b\x89\xac\xdd\xab\x97??\x7f\xd5cA\xaa\x96\xb2\xed\x8a\xb0\x9dT\xfc3\x98\
2064 \xd4\xd2@\x01`\x8f\x08\xaa\xael\xac\x91\x02\xd0\x8fF\x00F\xc3u\xaa\x92%Y\x12\
2065 \xab$\xc8\x05TC\xf7\xf8\xff\x91g\xb3\xc3\xef\x1b[\xd7ON\xb6\xb7\x1f\x02\x01\
2066 \xd4\xea\xe0Z1\xfe\x02ZAf\x94h\x00P6\x00\x00\x00\x00IEND\xaeB`\x82'
2067
2068 def getISBitmap():
2069     return BitmapFromImage(getISImage())
2070
2071 def getISImage():
2072     stream = cStringIO.StringIO(getISData())
2073     return ImageFromStream(stream)
2074
2075 index.append('IS')
2076 catalog['IS'] = ImageClass()
2077 catalog['IS'].getData = getISData
2078 catalog['IS'].getImage = getISImage
2079 catalog['IS'].getBitmap = getISBitmap
2080
2081
2082 #----------------------------------------------------------------------
2083 def getITData():
2084     return \
2085 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2086 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2087 \x00\x00\xe2IDAT(\x91\x85\x91AJ\x03Q\x10D\xdf\xc8\xdfy\x82\x11\x02\x12\xc89\
2088 \xb2\xf2\x16Yy\x077\xe6\x14^%\xf7\xc8\t\xb25\x17\x90\x08\xc3\xef\xeaj\x17##\
2089 \t\xa2\x8f\xa2{S\x0f\x1az\xe0\r&\x00\x0c\xe2\xfc|\xf65\x0f\x9b\x8daI\xe3\xc2\
2090 \xfei\x0f\xd8vy\x1c\xc7*\xa0jY\xbb]E\x94T\x11\x97\xc3\xa1\xd1\x80z\xff<\xa73\
2091 3\x7fz\x0b\xa7S\xf5^\x11\xc3jeh\x18\xbb\xd2)\xa72n\xdbU\xd5\xfb,\x10ah@\x92*\
2092 \xc9\x92u\xdb\xbe\x16\x80\x86\x9032\x94\xff\t\x92g!-Y\xdd]\xf9\x970D\x18\xee\
2093 \x10Q\xd1\xb3+\x15\xd9\x7f\x17"\x90J\xd2\xf7I\xa9\xc8\x98\xf3\xbb\xa0@I&\xd0\
2094 \x98\x08k\xbc\x1f#CJ\x00\x18\x86\x81\x85\xf5\x9a\xcc9\x86\x81\x17\xf8\x00\
2095 \xc1\x04\x13\xc7\xd7\xa3$\xdb\xf3\x04\x1e\xb7\xdb\xf9\xc73_.Vw\x84\xfc\x92\
2096 \xba\xce\x00\x00\x00\x00IEND\xaeB`\x82'
2097
2098 def getITBitmap():
2099     return BitmapFromImage(getITImage())
2100
2101 def getITImage():
2102     stream = cStringIO.StringIO(getITData())
2103     return ImageFromStream(stream)
2104
2105 index.append('IT')
2106 catalog['IT'] = ImageClass()
2107 catalog['IT'].getData = getITData
2108 catalog['IT'].getImage = getITImage
2109 catalog['IT'].getBitmap = getITBitmap
2110
2111
2112 #----------------------------------------------------------------------
2113 def getJMData():
2114     return \
2115 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2116 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2117 \x00\x01\xc8IDAT(\x91U\x91OH\x13p\x1c\xc5\xdf\xfeD\xb5\x9af\x1b\x83r5\x8b2\
2118 \xbd\x8c\x9c\x11\x91yH")\xf3P\xd0!D(\xa1S\x05\x1d\x83\xe8\x12H7oE\xd4!\x98\
2119 \x82\x07\xb1C\x97\xe8\x1f\x1d\xcaH\xcc"\xda lm\x14h9\xb2\x8d9k\xfb\xbe\xef\
2120 \xf7\xb7\x0e3\xa8\xc7;\xbc\xcb\xe7\xf0\xde\xf3\xd4\xdea\xa1\x8cS\x1f1\x9d\
2121 \x07\x008\xc0\x01\xfa\x8f\x05\xa8\x00\x11\xbc\x8f#\x1a\x80\xe7t\x17\x92cW\
2122 \xd7m\xc0t\xc1=.\xba\x92\x9a\xc2\xcc\xa9\xd6T\x9d*\xb9\xde\xab\xfd\x8d<\x1c\
2123 \xd2_E\xee\xeex\xe0\x9f\x98B\xf7\xfd\xda\x91\xc4\xfc\xfe=\xb6\xddk\xf7\xbe\
2124 \xf3\xcd\xb2\xb1F:\x92\x8c\x07x!,\xd1\xa0\xcc\xbe\xe6\xd8\xd3mK\x80\x0f\xc0\
2125 \xde\xceC\x8f^\x14\xe5\xb7\xedkaw\xc8|N>\xac\xa8s\x1c\x08\xc9\xe5\xa8\x04\
2126 \xc9\xbb\xe3r\xfd\x0e\xab\x16\xccf\xb3~\x00fV\xa9\xea\xc4\x13\x9dM\xeb`\x1fO\
2127 \xee`\xfb\x1a\x9a\xb1- \xa9\xb4\x8c\x8cr&%$7\x93\x00\xbc\x00T\x8d$\xc9t\x86\
2128 \xd7n2\xf7UZ\x83\xd2\xd6 \xb9/r\xe9\x06gRR\x97\xaa\xae\x02f\xaa\xaaBi\x8e\
2129 \xc8\x95\xb3\x12\xdb"\x99\xa2\xcc\x15\xaa\xb1\xad2|\xb1\xba\xaby\x15 \t\xc0\
2130 \x0f\x80\xa4\xaa\x9c\xe8\xd2\xc1\xe3\xb26\xc8\xc9y\xb9\xf5\x8d\xe2x>,g\x12\
2131 \x1c\xdd)#I\xde\x9eTSE\xbd\xf4\xd1\x9e\x8e\xa1\xbe\xa5\xfe^\xfe$\x87s\x92\
2132 \xccK\xd9X6y^`\xaa\xc4\xceF9v\x90\xf1\x98~Zh\x9a\xfb\xbc\xe8io\xc4\xd4\xcb\
2133 \xa1\x8d\x9b\xf8\xea\x07\xc7\xf3\xb6(\xaco\xaaN\xe9\xa8\xd4&\x9f\x9e\x0b[o\
2134 \xc4\ny\x8b\xf5\xa4<+\xcf\xb0PB\xe2-\x963\xff\xbf+\x7fs\x05P\xa0\x05\x0f\x0f\
2135 \xa0\xb5\x01\x7f\x00\xbc\xc6>\x16W\xa20\xbb\x00\x00\x00\x00IEND\xaeB`\x82'
2136
2137 def getJMBitmap():
2138     return BitmapFromImage(getJMImage())
2139
2140 def getJMImage():
2141     stream = cStringIO.StringIO(getJMData())
2142     return ImageFromStream(stream)
2143
2144 index.append('JM')
2145 catalog['JM'] = ImageClass()
2146 catalog['JM'].getData = getJMData
2147 catalog['JM'].getImage = getJMImage
2148 catalog['JM'].getBitmap = getJMBitmap
2149
2150
2151 #----------------------------------------------------------------------
2152 def getJOData():
2153     return \
2154 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2155 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2156 \x00\x01-IDAT(\x91\x95\x8e1K\x9bq\x18\xc4\xef\x8do\x9d\x84\x82\xb8d\x08\xc4j\
2157 \xbf\x80[\xd6N\xa1\x05!\x93 \x08n\x85.\x8e\x1d\\]\xba\xd4\xecnYJ\xa1 \x84R\
2158 \x08\x8a\x90!k\xb7|\x80@\xbb\x15$S\xe0\x7f\xcf=\xe7\xa0\x91\x0e\xef\xe2\x8f\
2159 \xe3\xb8\xe1\x0e\x0eWx\x19\x95\x81\x7f\xe7\xe7\x13`\x9e\x99\x99\x92"$\xc5\
2160 \x13$\xd7Nr<\x1e\xd7\x00v\xe0\xe3?\x7f\xef\xa4o\xd2\x92\x94\xc4g\n\x0bK)\x85\
2161 d\xa7\xd3\x01P\x03p\x1a\xd2;i\x97\xec\xf6?\xf8\xf4\xc4MTU\xb5X,Z\t@\xc2\xc1\
2162 \x813\xbb\x0cO~y4j\x1c\xd8\xce\xcc\x16\x00\xec\xef\xfb\xec\xcc\xbd\x9eI/\x97\
2163 \x1e\x8d\xfc\xf5\xb2\xa1\x0eDD\r\xc0\xf3\xb9\x87CO\xa7`\xb1k\x1f\x0e\xfc\xe9\
2164 c\xc3%\x1b@+\x01\x93\xbe\xbd\xc5j\xb5\xd8*~\xdfol\x03x\xbcT\'\xb0\x11a\xf2\
2165 \xe6-\x87\xfdM\xea\xba\xfc\xfcN\x91bQaF$)Fj\xef\xf5\x9b\xd9\xc5\xacN\xe0~3~\
2166 \x1c\xb5\x7f\xef\xbdj+"\x83"\x93\x91\x11\n9\x98!I\x96R\x08T_\x80\xcf\x03`\
2167 \x1b(k\xc5\x7f!\xd6!\x81\x00\x80\x07\xb8\x86[\xb9\xc4\xb5\xea\x16\x00\x00\
2168 \x00\x00IEND\xaeB`\x82'
2169
2170 def getJOBitmap():
2171     return BitmapFromImage(getJOImage())
2172
2173 def getJOImage():
2174     stream = cStringIO.StringIO(getJOData())
2175     return ImageFromStream(stream)
2176
2177 index.append('JO')
2178 catalog['JO'] = ImageClass()
2179 catalog['JO'].getData = getJOData
2180 catalog['JO'].getImage = getJOImage
2181 catalog['JO'].getBitmap = getJOBitmap
2182
2183
2184 #----------------------------------------------------------------------
2185 def getJPData():
2186     return \
2187 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2188 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2189 \x00\x01\x03IDAT(\x91u\x91=n\x021\x10\x85\xc7\xab\xad\xb6\xd8\x06\xd1Pp\x0cJ\
2190 \x0e@CAK\x81\x94\\\x0c%\x1d\xe2\x02\x144\xe4\x1a[ \x12i\x9bEB\x82"ck\xbe\x14\
2191 \xfe\t)\xf2d\xd93\xd6\x1b\xbd\xf7l\xf7x<\xe4\tf\x16\xf7\xe7\xa2 \x98\xd5"\
2192 \xd24\x8d\x88\x00q\x06b\x97\x8f\'\xf4}_g\x12\xbf\xc5\xf1\xc8\xe9\x03\xaf\xcc\
2193 f,\x16\x85\xed\x9c\xb3\xa8\xf0\x87\xbd\xdf\xb3\xdd\x12\x02\xea9\x9d\xf8\xfa\
2194 \xe4\xe55\x0eD\x87Uq\x0f\xc80\xb0\xdb\xe1=\xaai\xbd\xbds\xb9\x14\x91\x10B\
2195 \x15\xc3\x15\x8f\xdcn\x89\xea\x15U\xeew\xceg\xb2\x84\x99\xd5f\x96{d<\xa6\xaa\
2196 \xf0\x8azT\xf1\x1e\x11&\x93\x94\x01\x92\xa5\xc2g4b\xb9\xe4[\x13[\x95\xd5\x8a\
2197 \xe9\xb4\xbc\x98\x88\xd4\xc5R\x9a\xdclh\x1a\x0e\x07T\x99\xcfY\xafKb\x11\t!\
2198 \xb8a\x18\xda\xb6-\xb7\xa9\x88>\x9d\xcbiE\x04\x11\xe9\xba\xae6\xb3\xeb\xf5\
2199 \x9a?2X\xb0\xff\x10E~\x00&\x93l\x9f\x04-\x9d\xc4\x00\x00\x00\x00IEND\xaeB`\
2200 \x82'
2201
2202 def getJPBitmap():
2203     return BitmapFromImage(getJPImage())
2204
2205 def getJPImage():
2206     stream = cStringIO.StringIO(getJPData())
2207     return ImageFromStream(stream)
2208
2209 index.append('JP')
2210 catalog['JP'] = ImageClass()
2211 catalog['JP'].getData = getJPData
2212 catalog['JP'].getImage = getJPImage
2213 catalog['JP'].getBitmap = getJPBitmap
2214
2215
2216 #----------------------------------------------------------------------
2217 def getKEData():
2218     return \
2219 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2220 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2221 \x00\x01zIDAT(\x91\x95\x8e?OSa\x1c\x85\xcf{{\xd1Bjt\xb1\xeaRH7C\x98\xf4S\xf8\
2222 \x11\xca``E\xc3l\x1ae"awgbq\xad\x8b\x0b\xd1\x81\xa5\xeeDo\x1bcro\x03\xd2\x08\
2223 \xd2\xa0\x97{\xdf\xf3\xfb\xe3B\x13W\x9f\x9c\xe1I\x9e\xe5\x00\xffI\x00\xd0\
2224 \xef\xf7\x01\xd8\x1cU%)"\xa2\xea\xaaU]\x0bI\x11\x92\x83\xc1 \x01\x00\xf8d2)\
2225 \x8a"\xcf\xf3\xfc\xf4\xb4\xb7\xbe\xde\x9e\xcd\x1e\\\xfc\xda\xd8\xdc\xfcV\x14\
2226 \xe3\xf18\x1b\x8d\xb2,#\t \x1c\x0f\x87\xdd\xb557\xf39\xe5tj\x07\x07\x10\xb1^\
2227 o\xa9\xdd\xbe\tfI\xda8\x1a\xbc\x0fg\xc0\x9d\xd7;:9q\x11\x17Bd\xa7\xfa\xb3\
2228 \x1d\xd2\x05\xd57\xb3\x8b\xdd\xda\xac\xaa=FWM\x97;\xa3\xc3\x0fi\t4\xcbJ\xaf~\
2229 \xbb\x88G&&\xe7\xbc\xd6\x85\xa6S\xa7\xe5\xb5F\xf7:Z\xa4KDUG \xbd\x05$I@\x08\
2230 \x16\xe0!\x04\x0f\x97Bx#Qm\xa9\x05\x8a1\x82\x02\xb5\xa0\x06 \x1c\x7f\xf9\xd8\
2231 ]y\xaa\xaa7W\xdd.\x7f\xe4x\xbb\x9f\x88\xd6[\xcf\xef=\xea\xb8\x9b\xbb\x9by\
2232 \xdaH?\x1d\xbd\x0bx\x85\x17\xcf^~\xbd\xca\xa8\xa4\xc5h~\xdb\x16\x9f\x8c\x19"\
2233 \x0f\xbb<\xd7\x9f\xd1JQ\x8a\xe9\xea\xdd\xc7\x9f\xf7\x86)*\x88p\xa5\xd9\xa1RL\
2234 h\xa4\xf1\xfb\xaa\xd0\xf8P\xe5\xbe\xb5\xdcA\x13u15T\x08\xd8\x06*@\x808\x9f\
2235 \xfc#2\x17\x03\x04h\xe1/[b=+\x9c\x1eE7\x00\x00\x00\x00IEND\xaeB`\x82'
2236
2237 def getKEBitmap():
2238     return BitmapFromImage(getKEImage())
2239
2240 def getKEImage():
2241     stream = cStringIO.StringIO(getKEData())
2242     return ImageFromStream(stream)
2243
2244 index.append('KE')
2245 catalog['KE'] = ImageClass()
2246 catalog['KE'].getData = getKEData
2247 catalog['KE'].getImage = getKEImage
2248 catalog['KE'].getBitmap = getKEBitmap
2249
2250
2251 #----------------------------------------------------------------------
2252 def getKGData():
2253     return \
2254 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2255 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2256 \x00\x01*IDAT(\x91mQ1j\x95a\x10\x9c\xef\xcb\x13+\t\x06,\x02\xbeF\x1b\x83\x85\
2257 \xe29r\xa3\xdc\xc4\xca3\xe4\x02\x96b\x11\xc1\xc2Z\x84H\x82] \x81\xbc\x99\xd9\
2258 \x1d\x8b\xff\x7f\x89\x85\xcb\xb2l\xb1\xbb3\xb33n\xf0\x18\xbd\xaf\xff6\x0fi\
2259 \x00\xc0\x06\xc0\xd3\xb33\x00\xe9F7\xaa\xe2B9v\xecH\xb1!\xb5\x1d\xe9\xcf\xf9\
2260 \xf9\x06\x00\x90\xbe\xfc\x8d\xaaTE\xc2\x93\x1a[a\xa8\xbf\xabo\x15\xb1\xc9Hs\
2261 \xbb5\xb0i \x9d\xc7\xe9Q\x9bS\xce\x0fFi\x9cp\xf7\x89}\xa7\x90\x91"50\x01\xa0\
2262 \xea\x01}\xbe\xe1x-\x7f\xa5\xbfp\xbc\xe2\xc1\tC\x86+H\x03\xb3\x01\xb8\x96\
2263 \x03\xa1\xc6\x0b\xe5\x80\xb9f]\xb1\x07\xf3rO\x89\x8c\xed\x05!\x8bD1b\xfd"\
2264 \xee\x98C\xe2h\x97[\xf6\xe5n\x9d&[\xc2\xaaAZ\x0e\x80\xf47\x8d\xb7\x9c\xef\
2265 \x95R\xfd\xa0>+;Fj{\xda\xbd.,\x02VV\xbc\xff\xc8\xf9N\xb9\xa7/\xd47\n\xd9\x16\
2266 \\\xa9\xda\x7fI\x1e\xc7\xc7C\x8a\xab\xad!\xe5\xa7b\xcf\xe7\x1a\xcf\xdc\xf6\\\
2267 ~X\x05`\\\x01\xde\x1b\xd9\xffswq}\xb1y\x02\x7f\x01\xf6\xe7T\x82\x00#5\xea\
2268 \x00\x00\x00\x00IEND\xaeB`\x82'
2269
2270 def getKGBitmap():
2271     return BitmapFromImage(getKGImage())
2272
2273 def getKGImage():
2274     stream = cStringIO.StringIO(getKGData())
2275     return ImageFromStream(stream)
2276
2277 index.append('KG')
2278 catalog['KG'] = ImageClass()
2279 catalog['KG'].getData = getKGData
2280 catalog['KG'].getImage = getKGImage
2281 catalog['KG'].getBitmap = getKGBitmap
2282
2283
2284 #----------------------------------------------------------------------
2285 def getKHData():
2286     return \
2287 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2288 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2289 \x00\x01mIDAT(\x91]\x91\xb1jTa\x10\x85\xcf\xfd\xbdw\xf7\x86u\xafkX\xc8\xaa\
2290 \xb8hc)\x16\x06+;\x03na\x13|\x07\xed\x15AE\xb1\xb05\xe0#\x08\xa9\x0c\xbe\x81\
2291 \xc4B\xdf"6\x12\xb5\x10\xab &;\xe7\xcc\x8c\xc5M 8|\x0c\xa7\x18f8s*\x8c?\xc1\
2292 \x02}\t\xf0\x00zt\xd2O\x0b\xd40\xbc\xda\xba\x06 \x03\x1e\xe9\x01\xf7\xf0H)\
2293 \xe8p\x85\xd4\xeb$c\xe7\xed\x97\x1a\xf8\xd3\xa6\xfd\xfc\xb5\xf4\xc8\xf0\x90g\
2294 ?a\x1ebHI\x06\x19&\xbf\xb4\xd6\x02\xbf\xeb\xcf\xcb{W\x7f<\xb5\xfd\xfdpO2=\
2295 \xdc\x96\x83\xd9,<\x0e\xbf\xeeA\xee\xcb\xa34Kr0\x9f\xdf\xc6\xc7\x02\x00\xee)\
2296 U$\\\xa3\x1b\xd7\x07\x93s\xb3\xe7\xcf.\xbc|\xd1\x8cGgo\xad\xc3\x95fi\x06\x12\
2297 @\x11\x10\xf2 EfUV\x1f<\x1c\xdd]\xa0]A\xdbv\x9b\xf7\xa7\x8f\x1eg\xdd\xc8Lf\
2298 \x92\x8e\x80\x1a\x00\\\x90\x92vf\xa5+]\xd7m\xdc)\x93\xf3i\xd6-\x16e2)\x83\
2299 \xe6x}\x7f!\x80$\xc3\x0c\xee\x17\xdfl\x01\xa8\x9a&3\xb3\xae\xab\xe10\x81\xf9\
2300 \xf6v\x95\x1eRH\x02*\xe0\xdd\x93\xd77\xbf}\xffK\x86PH\'\x83tcPA\x85<yH\xb9_\
2301 \xb9<\xda\xddy_\x03\xdd\x01\x87\xe3iC\xf5^\x82\xc7\x8f\x0f)\xddS\xbd\x88<\
2302 \xf0\x04\xa6\x15\xf0\x01\xb0\x93 \xff\xe3t\xd2=\xe5\x1f\x8c43\xadX\xc5\xfd\
2303 \x9e\x00\x00\x00\x00IEND\xaeB`\x82'
2304
2305 def getKHBitmap():
2306     return BitmapFromImage(getKHImage())
2307
2308 def getKHImage():
2309     stream = cStringIO.StringIO(getKHData())
2310     return ImageFromStream(stream)
2311
2312 index.append('KH')
2313 catalog['KH'] = ImageClass()
2314 catalog['KH'].getData = getKHData
2315 catalog['KH'].getImage = getKHImage
2316 catalog['KH'].getBitmap = getKHBitmap
2317
2318
2319 #----------------------------------------------------------------------
2320 def getKRData():
2321     return \
2322 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2323 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2324 \x00\x01\xcaIDAT(\x91MQKO\x13a\x14\xbd_[\x98v\xc6\xb6\xd3N\x19\xd2\x8e$ \xc5\
2325 \tFTR\x16\xae5\xd2\x86\x1f`p\xe7\x0f\xf0\xc1\xd6\x10m\xe2\x9e\x05\x0b\xfb\'\
2326 \x84\xb8\x9a\x85\x89\xc1\xd7\xaa\x89\x8f\xa8q\xd1E\t\x01R\xfa\x98\x89S\xb5)u\
2327 >\xefa1b8\xc9\xc9=\xabs\xcf\xc9\x11\xfd\xe1\x80\xce\x80\x99\x89\x889T\xffx\n\
2328 \xc9\xcc\x11"J\xc5\xd5T\\m\xed\xed\x7f\xff\xfce\x0c"\x15\xd7tUMkZFK&\xa2\xd1\
2329 o\x1f>\x1e4\x9b\x13\xe9\xb4\xa9g\x999\x16\x1a\xf7z=\xc7q\xfc\x1f~\xce4ggf\
2330 \xd0lBJ\x14\x8b\xadvg{{K\xcfd\x8cl\xf6\xfc\xd4\x94\x0c?\x00\xf0}?\x08\x82\
2331 \xc5\xa5\xd2l!\x8f\x8d\r\xac\xad\xe1\xc1=<Y\x9f6\'\x96WV\\\xd7=j\xb7\x010\
2332 \xb3\xe8\x0f\x07I%AD\xddnWM&\xc5\xab7\xf1g\x9b\x08\x82\xdf22\x1a\xfd\xd1\xef\
2333 \xae\xfe\\\xbd\xd3\xef\xb9\x05\xab \x84\xd8k\x1d\xc6\xc2\x96\x00r\xb9\x1c\
2334 \x11\xbdtS%\x19\r"\x89\xa7\x8b\x0f[#e\xfd\xe0\xd3UE\xd1\xac\x02\x00\x12B2\
2335 \xc7\x98\t\x00\x00\xcf\xf3\xcei\xea\xc0^\xb8o?\x8a\x8e\x8f\xed+\xa6\x7f<j\
2336 \x96\x96\xed\xe1/\xd7\xeb\xe7\xf3y\x01\x10s\x84\x98\x014\x1a\x8dZ\xad\xe68N\
2337 \xe5Zb\xeez\xf10\x9a\xa5\xe1\xf1\xcd\xcb\xe3\xb7nX;;\xaf\xab\xd5j\xbd^\x0f;\
2338 \xc4\x98\x88\x88TU\x05\xf0\xf6\xdd\xfb\xf9K\xf3\x8fo_\xfc\xba\xa4\xc8\xbfX\
2339 \x98Vvw\x1b\xcf\xb7^\x18\x86\xa1\xeb:\x800\x12\x03\xb0,\xab\\.w:\x1d\xd3\xcc\
2340 \x13\xd1\x95\x0bj\x98sr\xb2P\xa9T\x0c\xc3\xb0m\x9b\x88\x88I\x1cy\xde\xd9!\
2341 \xff\x1f\x92,O\x87&)%\x111\x11\xf1\t\x851\x197fc:\xfd\x00\x00\x00\x00IEND\
2342 \xaeB`\x82'
2343
2344 def getKRBitmap():
2345     return BitmapFromImage(getKRImage())
2346
2347 def getKRImage():
2348     stream = cStringIO.StringIO(getKRData())
2349     return ImageFromStream(stream)
2350
2351 index.append('KR')
2352 catalog['KR'] = ImageClass()
2353 catalog['KR'].getData = getKRData
2354 catalog['KR'].getImage = getKRImage
2355 catalog['KR'].getBitmap = getKRBitmap
2356
2357
2358 #----------------------------------------------------------------------
2359 def getKWData():
2360     return \
2361 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2362 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2363 \x00\x01(IDAT(\x91}Q?J\x1dq\x18\x9c\xdd\xac"\xf1a\xf1L\xc4\'H\x1aO\x10\xde\
2364 \x01\xbc\x84\x9e!\x9dm\xe0\x9d\xc0>\xea\rr\x80W\xe4\x06\x1e\xc0\xda\xd6\xb4!\
2365 \x10\x91\xe57\x7f\xbe\x14\xeb\x96\xfa1\xc50\x0c|3L\x07\x00\xd7\xc0\x1e0\x02#\
2366 \xa0\x19\x99I\x9b!@\x18\x00l\xb2\xc1W\xe4c\xc2\xb8\xac\xd8\x91J\x8a\x14\xd2R\
2367 \xc8\x88\xe6\xf6f;\x00\xc0s=\xfd\xfc\xeds\xfb\xd04\x1d3dH\x93fski4O\x17\xa7\
2368 \x181\x00H\xca\xff\xac_\xbe\xbc\xba8\xf8|\xe08\x89\xcb\xa9$veR\xf6w\xf6w\xbf\
2369 \xed\x0e\x00lK\xd2\xa8\xf5r}\xb2:\xa97\xae\xeb\xba\xf5b=\x00\x90LRR\x90\xb7\
2370 \xdcU\x85\xaeK\xd2\x03\x98\x1e46\xbfc\xafBU\x92\x01\x00\xc9\xd6ZA\xba\xbf\
2371 \xcfriO\xf9]\xf6\xd4\x02I%\xfdb\xf1|w7E\xd2\x00~\x7f\xe1\x97\xdb\xdb\x97\xd6\
2372 \xaa\xb5"\xab\xb5\x90\xafD\x84\xfc\xe1\xec\xec\xef\xc3\xc3\x00 \x9d~|Z\x1d\
2373 \x93\xa3\xdc\x8b5\xf9\xa4\x9e\x9c\xc6\xe8m\xd8e\xf7@\x07\xe0\x118\x02\xfe\
2374 \x00\x99\xf7\xc5L&\x05\xb3\x08\xe0?\x9dhe)?\xb4zO\x00\x00\x00\x00IEND\xaeB`\
2375 \x82'
2376
2377 def getKWBitmap():
2378     return BitmapFromImage(getKWImage())
2379
2380 def getKWImage():
2381     stream = cStringIO.StringIO(getKWData())
2382     return ImageFromStream(stream)
2383
2384 index.append('KW')
2385 catalog['KW'] = ImageClass()
2386 catalog['KW'].getData = getKWData
2387 catalog['KW'].getImage = getKWImage
2388 catalog['KW'].getBitmap = getKWBitmap
2389
2390
2391 #----------------------------------------------------------------------
2392 def getKZData():
2393     return \
2394 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2395 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2396 \x00\x01\x93IDAT(\x91M\xd1\xdfk\xcdq\x1c\xc7\xf1\xd7\xf7{\xbeZ\xedp6\xbb`\
2397 \x895\x8d\xd4\xb2R\xc8\xcd\x8ar\xa1\x95\xbbq\xc1%\x85\x1b\xb9\x14W\xee\xdc-\
2398 \xb5\xab\x15%\x94\x1b'w\xd2\xa2\xa3\xfc*WrA\x9aq3+t\x9cM\x93s\xbe\xdf\xf7\
2399 \xe7\xf9r\x83\xfc\x01\x8f\xabGVk\xf9\x83\xb2\xf1\xc2\xfdR\x88\xd5\x90BB\n\
2400 \x04\x02\x05\xcaQ\xa0@\xa5\xb2Z\xcb\x9d\x9d3\xcb\x1ay\xa4\xe9da%\t(\xdc\xedQ\
2401 \xeb\xaaH8\xe1\xb0+\xfb\xda\x8b\xb5B\xd2\xb2\xb6\xdd\xaa\xa6s\x0b\x14v\xd8[y\
2402 \xbf\xc7\xad6\x1b\x1f\xfb\xe8\x1a}\t\x07\xde\xdc\x97\xa9$\x97$\xf9\x98\xe7\
2403 \x12\xea\xd9\xc9\x98j\x9f\xe7'\xb9\x7f\x90\xe6\x01\x1e\xfc\xc2\x15\xae\xec\
2404 \xc0\x82<\x89a\x7f\xbc\xcb\xd9\xb03W9\xdd\xba\xdb\xe3~f\xf5\x1aZ\xda\xeb\x87\
2405 uV*\\%\x87\xadR\xb9\x90\x9d\x8e{\xb6\xb4\x07\xf8\xd2O{\x17\xaf^\xa7\xfd\x8e\
2406 \xb2\x13\x83oc\xf7Dz^\xe1\nG\x92\x82B\xa1\xcf\x1e\xb9\xed\x93\xe0\x1f\xd4\
2407 \x87\xbd8\xe1'\xf78\xb5\xc0\xf6o\x0c\xad\xd08\xec;\xf3\x1c\t\x1cXA\xae\xc0N'\
2408 \x98\x01\xb5\xbda\x95\xfa\xa746\xe5\x1b\x93n\x8e\xfa\xcdy_h3\x148P\xb2E\x14\
2409 \x12[X\xb8\xc8\x15\xe1d-\xb2\xe3\x1dc\xeb\xf9:\xe5\x9b\x83,\xcd\xa5\xcbO}(\
2410 \xfb\x03$T(\xc0\xd5\xb9u\xd7\x9b>\x1d(\xac\n\x05\x9b^\xfa\x0c\xd0\xf1\xc0(N\
2411 \xce\x12N\x96\x82L\xcd\x9fW\xa3q)\xff\xfe\xefR\xe5\xdf\xd7\xf8oZ\xa8+\xe5\
2412 \xfa\r\xbfiZs\xa4\xc5\x10\x93\x00\x00\x00\x00IEND\xaeB`\x82"
2413
2414 def getKZBitmap():
2415     return BitmapFromImage(getKZImage())
2416
2417 def getKZImage():
2418     stream = cStringIO.StringIO(getKZData())
2419     return ImageFromStream(stream)
2420
2421 index.append('KZ')
2422 catalog['KZ'] = ImageClass()
2423 catalog['KZ'].getData = getKZData
2424 catalog['KZ'].getImage = getKZImage
2425 catalog['KZ'].getBitmap = getKZBitmap
2426
2427
2428 #----------------------------------------------------------------------
2429 def getLAData():
2430     return \
2431 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2432 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2433 \x00\x01fIDAT(\x91e\x91\xbdj\x94a\x10\x85\xcf\xfb\xedg\x84EML\\\x15\xd4\x14n\
2434 \x99\xde\xd6NH\xa1\x16\xa9\xacDHc\xb7\x9d\x84\x08\xb9\x06\t\xd8\xda\n6\xb2w\
2435 \xe0}\x98""\xf9\xc1h4\x89d\xbfw\xce9c\xb1\x18V\x9cbx\x0e\x87\x81\x81\xa7\x08\
2436 \xff\x8c\x01\xff\x85\x8b8\xcbE@\xd9\xdc\x04\x906\xec\x94@A\x04\x99dF\\lD\x9c\
2437 \x8d\xc7\xed\xa8\xf7tm\xf0\xe0\xe4\xf08e\xcb\x96j\'\x86D\xa5\x08Y\xa4H\x06\
2438 \xe7o/na\xdcn\xdf\x1f\xdd[\x1c\xee\xab\xa3SBW\xb54\xdf>{4\xc8\xccw\xe3\xfd\
2439 \x9d\xbdI\x01*\x15\xf4\x9d\x1b\x97w\xf0\xa6\x01\x1dBu\t\x95\t]\x9a\xf2\xea\
2440 \xf9\xdd\x95a\x7fe\xd8\xdfx\xb1<7\xd7\x9c\xd5\xecX:\x96\xce\x05\xa8\r\xaa\
2441 \x950%*:-\\i\xae\xf6{\x99\x99\x99\xd7\xaf\xf5n-\xf4\xeay0\xc8 %\x80\rh\xc9\
2442 \xd5\xa8\xca0\x0e\xbe\xc7\xc9oN\x0f\x8e~\xc5\xeeAG\xa0cV&#\x01\xb6\xa8\xa42\
2443 \xc2T\xda8>\xe7\xc6\xdb\xdd\xf5\'7\x01l\x7f\xd8;\xfc\xc9\xa6\xa0\xd2\xa2\x95\
2444 \x06\\\x1e\xe3\xe1\xfa\xd6\xcb\x1f_\xbf)$\x8a\xc1:\x99\xfe \x85\x9b\x94(\x89\
2445 \xa2\x97\x96\x07\xa3\x8f\xaf\xdb\xf7\xf8t\xe9\xcb\x10\x8c\x8cH*\x19p\xd8\x91\
2446 \xc9\xccH\x12$$K\xf8\xacU\xa0\x9c\xfe\'\x953<\xad8\xe3\xfe\x0fF\xcfDl\xce\
2447 \x11\xc4\\\x00\x00\x00\x00IEND\xaeB`\x82'
2448
2449 def getLABitmap():
2450     return BitmapFromImage(getLAImage())
2451
2452 def getLAImage():
2453     stream = cStringIO.StringIO(getLAData())
2454     return ImageFromStream(stream)
2455
2456 index.append('LA')
2457 catalog['LA'] = ImageClass()
2458 catalog['LA'].getData = getLAData
2459 catalog['LA'].getImage = getLAImage
2460 catalog['LA'].getBitmap = getLABitmap
2461
2462
2463 #----------------------------------------------------------------------
2464 def getLBData():
2465     return \
2466 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2467 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2468 \x00\x01PIDAT(\x91UQ\xbdJ\x1e\x01\x10\x9c=\x0f\xedD;\xb9\x88\x82\xcf\xa0\xe6\
2469 -\xf2\x0c\t1V>A|\x00mEk!u:-\xa2!\xa4\xb2\x08\x12\x90\xf8EL\xa1D\x94\xc4\x0f\
2470 \x0b\x1b\xf13\xdf\xed\xecN\x8a\xe3N]\x96a\x16f\x96\xfd\xb1\xdfx\x8cl\xb1!ly\
2471 \xb6\x9c@\t`j}\x15\x802\x91\xa9\x08E\x88T\x10\xa4\xe8"\x93.\x12\xf4\x9f\x1fv\
2472 J\x00(\xcb\xb8\xfe\x8b\xa4\x18\n\xaa\xd5\x89\xae\xda\xd3]\xacU{QM\'P\x8e^]\
2473 \x8dU\x15\x00H\x92\x00\xbb\xb9\xbf\xd9>\xdc\xfe7|x\xf3\xf2m5^)S\x92$3\x8c.\
2474 \x1d\x15(\n\x98\xc1Lf\xb0B\x86\xfd\xf3/\xc7\xfd\xde\xf7\xfe\xd1\xde\xd9\xbe+\
2475 \x05\xb4i\xcc,2\xb3\xed.A\xc7\xfd\xde\xe7\xd3\xbd\xdb\x87\xdb\xda\x87\xbb\
2476 \xbd\x9d_\xfd\x13u\x01dc\xe8\xd4)m\x1dl\x86B\t\x0f\xaf\xc3\xd7\xbe\xae\xb3\
2477 \xd3K$\xcb\xce\xd0\xac\xb1\xf1j\xe3\xcf\xdd\xf5\xf2\xc7\xa5P\xbc\x9b\x7f\xbd\
2478 0\xb3\x18\xe9\x86\x91f\n\x00v\n\xbcx\xbf\x12\x97\x17b\x9d\xeer\xcfz(:\xeb\
2479 \xa1\x91"\xe5\x14]\xc1rv\xee\xdb\xa7\xc3\x92\x80\x06\x03\x9b\x98\x04\xbd`\
2480 \x88n\xee\xa2\x17\xce\xa4\xa3\xb9r\x84\x18\xba\x1f\x00\xb0\x1f\xcf\x1f\x99O\
2481 \x1e\xdc\x95h\x11\xc0\x7f\x10SD\xe6\xa3\x9b\x8a\x95\x00\x00\x00\x00IEND\xaeB\
2482 `\x82'
2483
2484 def getLBBitmap():
2485     return BitmapFromImage(getLBImage())
2486
2487 def getLBImage():
2488     stream = cStringIO.StringIO(getLBData())
2489     return ImageFromStream(stream)
2490
2491 index.append('LB')
2492 catalog['LB'] = ImageClass()
2493 catalog['LB'].getData = getLBData
2494 catalog['LB'].getImage = getLBImage
2495 catalog['LB'].getBitmap = getLBBitmap
2496
2497
2498 #----------------------------------------------------------------------
2499 def getLIData():
2500     return \
2501 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2502 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2503 \x00\x01VIDAT(\x91e\x8c1j\x94a\x18\x84\xe7\xff\xf6\xd3\x10%\x8bFX\x08\xb2B"\
2504 \x06,\x02B\xca\xdc\xc0#\x08\xde\xc2\x0b\x08z\x894)\xc5J\xd2\x05\xb5\xf0\x00\
2505 \x82\x85\x18\x90X\xc4FQ\x82``\x97\xe4\x9d\x99\xf7\xb5\xd8\xa4P\xe1a\x98\x81\
2506 \x87\x190}\x81\x04\x1a\x80\x06\x01\x12bA\xc2\t\x08\x10\x10\x97E\x1d\xc2\xd3\
2507 \xe7\xdbwV\x7f\xde\xbd\xf5\xed\xc1\xf4\xcb\xfb\xaf\xeb\x87\xdf\xd7\x8fOV\xa5\
2508 R\x96\x94rJI\xa5\x9c/\x9f\xedw4\x00\xf5ps\x7f\xa9\x9f5\xc5\xce\xf4hc\xbc\xf2\
2509 \xe4\xe3c2\xe9\xa4L%\x95\xa4oO\x96\x015\x00Y8\xf8\xb4u\xfd\xea|it&\xeb\xd5\
2510 \x87mr\xa1:\x94A\x07\x1dJ)\x81\xe8\xc8\xc6\x1c\xde~\xdezs\xb8)\xe7\xb9\xafP\
2511 \x08\x9b\x86\x88\x10\xe8!\x04\n\xe7\x06\xd0\xfa\xfd\xd3\x83{\xf3\xf1\x8d\xd9\
2512 o\xa9,[\xb4$\xa5h\xd2\x92MI\x96<\xb9v\xf35v\xfb\xbb\xd9\xde\xca\xaf1~\x1c\
2513 \x97\xa3\xa8"\x8b\xf1\x7f\xa68j\x1b\x8f0\xebs`\xd9\xd4\xc2V$Y\x8a\x14KLE\x91\
2514 \xa5(\xb1\xa4\x91u\x02t\x00%\x15\x99\xe4\xc5\x19\xa3\xc8\xbc\xf8f1JL\xbb\xd9\
2515 \t\xf4\x04J\x1a&kM\x84\x9c\xe4`&\xd9\xa4\x14!\x95\x94\xe9f\xc3N`8\x02\x04\
2516 \xe4e\xe2\xef\xf9\x0f\x00\xfe\x00}\xfba\x01\x98\xd1\xdd\xe0\x00\x00\x00\x00I\
2517 END\xaeB`\x82'
2518
2519 def getLIBitmap():
2520     return BitmapFromImage(getLIImage())
2521
2522 def getLIImage():
2523     stream = cStringIO.StringIO(getLIData())
2524     return ImageFromStream(stream)
2525
2526 index.append('LI')
2527 catalog['LI'] = ImageClass()
2528 catalog['LI'].getData = getLIData
2529 catalog['LI'].getImage = getLIImage
2530 catalog['LI'].getBitmap = getLIBitmap
2531
2532
2533 #----------------------------------------------------------------------
2534 def getLTData():
2535     return \
2536 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2537 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2538 \x00\x01 IDAT(\x91U\x8d1N\x9cQ\x0c\x84\xe7_\x1eB4\xa1\x06\nN\x80\xe8\xb8A$N\
2539 \xc4\x05\xa2\xdc#m\x8a4\xa9\xd3p\x02D\xa2TTP \x05\xa5B+\x81<\xe3\x99\x14oY\
2540 \x82e\x8d>\xdbc{\xe1o@\xd8\x86\x05\x030\xe0\r[\xaf,x\x85\x01au\xf4\t@\xd2\
2541 \x88w\xd0;1\xa2l\xd3B\x98\x08\xe6\xd3\xaf\xafc\xac\x80\x05\xd1\xc3\x92\x9e>\
2542 \xa4\xe7\x18\x99Y1c.\xbb\xc7\x00\xc6\xcf5\x8eJ,&=O\xdaL4MNy\x82kw\xaf\xae\
2543 \x1f1\xce~\xe0\xf2\xe3\xf3\xfdz\xad\x96,\x9a4\xd9,\x93]\xd5\xc5\xe6\xd4\x93\
2544 \x0f\x07W_0\xf0\x02\xb9\xd9\x94%\x8b\xcdr\xb1I\xb3\xba\xaa\xdf\xd6\xd4\xc2\
2545 \x1a\x03@G\x8a\xca\xa5\x9e\x1f\xaa\xbcY+\x17\'\x87\x0c\x01\x8co\x9fq\x1a>\
2546 \xdf\x95\xa9\xa8\xbahM\x1b\xcd\xdah3\xd4\xfe\x89\xbe\xdf`\x9c\x03\x07\x7f\
2547 \xd5\x7f\x18\xd2d\xaaR\xb5\x81mG\x8cz\xec\xf7\x050\nh*\x87\x87!\xa1\x8e\x18\
2548 \x12$$\x90\x8b\x04)\xddK\xb7\xba_\x80\xe5\x16\x10\xe0W\xf5\xfb\x12\xff\xf5\r\
2549 \xac\x80\x7f%"wC\xeb\n\x9e\x0b\x00\x00\x00\x00IEND\xaeB`\x82'
2550
2551 def getLTBitmap():
2552     return BitmapFromImage(getLTImage())
2553
2554 def getLTImage():
2555     stream = cStringIO.StringIO(getLTData())
2556     return ImageFromStream(stream)
2557
2558 index.append('LT')
2559 catalog['LT'] = ImageClass()
2560 catalog['LT'].getData = getLTData
2561 catalog['LT'].getImage = getLTImage
2562 catalog['LT'].getBitmap = getLTBitmap
2563
2564
2565 #----------------------------------------------------------------------
2566 def getLUData():
2567     return \
2568 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2569 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2570 \x00\x01\x1aIDAT(\x91}\x8f1J\x83Q\x10\x84\xe7%\xafPD\xe3\x0fb\x04AA\x11l\xac\
2571 \xbd\x85\x95x\x12\x0bm\x03\x16\x9e\xc2s\xe8\t,<\x86\x95\xbf\x81\xa8\x11\xc3{\
2572 ;3\x16\x7fL\x1auX\x86o\x87ea\x92OO\xf0>\x01\x00@\x12J f(\xa1RT\xaa\nT!,'c\
2573 \xf2\x8a\xeb\x11\x00K\xc9B\xd0\x16\xc8D\xf5\xc9^T\x93&\x1d\xd5\xe4tt\x9b1+\
2574 \xa8\xc5\xed\x0bDP\x8e\x00\xc3\xa4\x83\x8e\xea\x1a\x8e\xea\xa8\xae5\rw\x04d\
2575 \x9c\x9d\xfb\xe0\x08[\xdb\xa0l\x822\xe9\xb9\x87I\x8b\x8e0\x89\xc1@\xfb\xc34\
2576 \x1e\x8f\x9b\xa6\x01`\x1b\x86\xe1\xbf\x94Rj\xdb6wu\xbbh\x01\xbf\n)I\xca\xcb\
2577 \xa3\xff\xff\xdb\xc9\x96\x94/\x1f7.\x8e=\xf92\x05\xda\x94)\x87\xbc\xe0\xae\
2578 \x8e\x84f\xd5W\xf7\xfd|\xf7\xa4\xc3\xcd\xfe\xf3\x87+\x11r\xa5+\x1dt\x95c\x01\
2579 r\x08{\xebx{@\x06\xd4Cow\ra\x07A\x81BU\xea \xd4%\x89\xb6\x04d\xa5t\xf3\xe9\
2580 \xa9\x10B\x11\x8a\x10@\xf9Y\xa59\xabs`\x05\xdf\xe1\xc4yk:}\nf\x00\x00\x00\
2581 \x00IEND\xaeB`\x82"
2582
2583 def getLUBitmap():
2584     return BitmapFromImage(getLUImage())
2585
2586 def getLUImage():
2587     stream = cStringIO.StringIO(getLUData())
2588     return ImageFromStream(stream)
2589
2590 index.append('LU')
2591 catalog['LU'] = ImageClass()
2592 catalog['LU'].getData = getLUData
2593 catalog['LU'].getImage = getLUImage
2594 catalog['LU'].getBitmap = getLUBitmap
2595
2596
2597 #----------------------------------------------------------------------
2598 def getLVData():
2599     return \
2600 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2601 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2602 \x00\x01\x1aIDAT(\x91u\x911jBQ\x10E\xef\x93\x87B\x14R\x0bj\xe1^\xd2d)\xf6!\
2603 \x85\x0bH\x9d2\xdbp\x13b\xf3\xb7`\x08I\x11H\xa1\x92\x80\xcc\x9d;\x93\xe2\xff\
2604 /\xa6\xc80\\\xee\x83\x997\xc3\x9c\xf2\x0c\x9c\xd1E\x00\xde\xebuZ\xaf\x03\xa0\
2605 ~\x03w\xeb5\x80\x8c\xc8\x88\x94\xc2\x15\xf2t\x0f\xf7 \xe5\x1ed\xb8\x8b|\xd9l\
2606 j\x05\x80\xfcy\xffH)\xa4 [\x15\x19\xa4\x8c\xa2\x85\x99\xc8\xf1|\x1e@=\x03\
2607 \x1e\xc9\xebj3\xb9\x87Q4\xd1d\x94\x99\xc8!y\x02\xca\xe7n7Y,d\x96\x99\x88H \
2608 \xda\xdd2;\x13\xdd\xa3\x0e\x87\xaf\xdbm\x91TJ\xc9\xcc\xcc\x04\x90\xffG\x19\
2609 \x0c\x8e\x87C\xfdj\x9a\xf1l&3t\x7ff^&\xf4\xbe\x1dUG\xa3\xb7\xdd\xae<\x02\xf7\
2610 \xab\xd5q\xbf\x0fw\x99\x05\xbb\x8du1f\xed\x95n\x97\xcb\xa7\xa6\xa9\x01\x84{\
2611 \x92\xd1\xa6Y\x98\x05\x99fIfk\x9c\xe9J\t@5 \xe97\xd3i\x90\xe1\x92\xf7\x9d=\
2612 \x84t\x97\xd4\x1e\xdd\x81\xf2\x00\x9cz\x90v\x05\xd5\xfebn\xf1O\x80_|(\x81I\
2613 \x94\xd8|\xd3\x00\x00\x00\x00IEND\xaeB`\x82'
2614
2615 def getLVBitmap():
2616     return BitmapFromImage(getLVImage())
2617
2618 def getLVImage():
2619     stream = cStringIO.StringIO(getLVData())
2620     return ImageFromStream(stream)
2621
2622 index.append('LV')
2623 catalog['LV'] = ImageClass()
2624 catalog['LV'].getData = getLVData
2625 catalog['LV'].getImage = getLVImage
2626 catalog['LV'].getBitmap = getLVBitmap
2627
2628
2629 #----------------------------------------------------------------------
2630 def getLYData():
2631     return \
2632 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2633 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2634 \x00\x00\xdcIDAT(\x91UQ\xdbm\xc3@\x0cc\x00\x7f\xa4\x13\xb4@F\xe9tA\xa6\xe8\
2635 \x00\xfd\xc8b\x99\xa1\x10\x1f\xea\x87l\xc7>\x08\x82tG\x8a<\xe8\x82\x1f\x9c\
2636 \x8e\x80\x00\xdab\xeaz\xe7\x05\xc0\xe3\xfb\xd1@\xe0t\xdcN\xa2H-\xb5\x14)b(\
2637 \x8b\xcd\xe7\xefs\x01\xd0\xe8\xd7\xdf\xcb\xb1\xdb\x83\x18\xd0D\x85t1\xbc}\
2638 \xdcV\x85t\x1c\xcf<\xc7\x0c\x15\x95\x8bM\x864iVJ-\x14\x16\x04\x86\xc7\xc3\
2639 \xa0WP\xc8Tmu\xb9hBC\x88\xd5b\xe4h\x83\xb2R4+dj.\x1d\xa3\xb0@pkl\xec\xe8\xf1\
2640 p$\xcbb\xb8\x12d\xd3\xdc?:\xea\xbb\x08\x9b\xf3*\x0b\x19B\xebd\xfd0\xbeB\x852\
2641 \x19\xbb\ra\x81\xc0\xf0\xf3\xfa\xe5\x88\x91\xf2\x96\x92eH\xb6"\xb7\xddFp\xc1\
2642 \xfd\xb4\xc85O\x91C;+\x07\xfe\x01\x7f(\x90\xf3\x07b\x051\x00\x00\x00\x00IEND\
2643 \xaeB`\x82'
2644
2645 def getLYBitmap():
2646     return BitmapFromImage(getLYImage())
2647
2648 def getLYImage():
2649     stream = cStringIO.StringIO(getLYData())
2650     return ImageFromStream(stream)
2651
2652 index.append('LY')
2653 catalog['LY'] = ImageClass()
2654 catalog['LY'].getData = getLYData
2655 catalog['LY'].getImage = getLYImage
2656 catalog['LY'].getBitmap = getLYBitmap
2657
2658
2659 #----------------------------------------------------------------------
2660 def getMAData():
2661     return \
2662 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2663 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2664 \x00\x00\xecIDAT(\x91}Q1J\x04A\x10\xac9\x17\xb9/\x9c\xb0\xa9`bb\xe0\xe3\xeeW\
2665 \xf7\x8cCCA\x033\xcd\r\xee\x10\xbb\xaa\xbb\x0cf\x8f\xdd\x05\xb1)\x8aa\xa6\
2666 \x8b\xae\xa9n\xc6\\\xb5>\xff\x89f\x00\xfb=\x00W\xa1\n\x99V"e\t\x92I/\xf8t8\
2667 \x0c\x00\x00\xfb\xe3\x13\x99\xc84\xd9yB\xd0\x0cG\x98l\xe3X\xc0\x00\xc0\xe5Uw\
2668 DI&\x11a\x86\x83]\x00\xb2\x80\xa1\x80\x96\t\xc9\x12(\x8b\xdf\xe6\xf3=K|8\xc6\
2669 \xf5O\x98\xb3\x00\xc0\x06\x00\xb4\xf0@\xbe\xdf\xc4y\x1b\xa7m\xbc\x8e\x97\xee\
2670 \x0e\xe9b)e\xc9\x0cP&o\xdf\xe2\xcbL\xc5\xdd\x0b\xbd\x98\xd0fK\xa4# \xf5\x87\
2671 \r\xe3\xf1\x89&\x8b\x0b?\x92%u\xc1U\xff\xe2\x14\xcb\x94\x89#\xe6\x1b\x11Jd\
2672 \xa2\x0b6\x14v;\x93PB\x04\xd9HH\xe8,\xf5\x0c\x91Y@;\xaf\x17\xf9\xcf\x8e{\xfd\
2673 \x02\xf9\xcbZ\xc0\x13\xfe\x86t\x00\x00\x00\x00IEND\xaeB`\x82'
2674
2675 def getMABitmap():
2676     return BitmapFromImage(getMAImage())
2677
2678 def getMAImage():
2679     stream = cStringIO.StringIO(getMAData())
2680     return ImageFromStream(stream)
2681
2682 index.append('MA')
2683 catalog['MA'] = ImageClass()
2684 catalog['MA'].getData = getMAData
2685 catalog['MA'].getImage = getMAImage
2686 catalog['MA'].getBitmap = getMABitmap
2687
2688
2689 #----------------------------------------------------------------------
2690 def getMCData():
2691     return \
2692 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2693 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2694 \x00\x00\xc9IDAT(\x91\x85\x8fKj\x03A\x10C_\x0f\xed\x0bxi\x98\x93\xfaV\xbe\
2695 \x81O\xe1\x0b$`\xf06\xabn\xb5\x94E\x0fN\x868\x89(\n\x15%\xd5\xa7\x84/x\xcf_F\
2696 \tp>\x03\xb1\xb1\x19#\x1a\x0cEBJ\xef\xf9\x96?.\x97\n@\xf2\xf6\xce\x18\x8c\
2697 \x91\xdeg\xde\xa2\xf5\xf4\x96\xd6\xd2{YWC\x05\xe2\xec\xd4\xadE\xda\xa4\xbd\
2698 \xa5\xf5i\xa0wC5\x941\x90"\xd1\x15\xbd\x98\xfd4\x00\x95\xc3\x81uM\xad\x19\
2699 \x9e\xa7o\x17\xffx\x80\xd3\xc9\xd7ky<\x1e\xc7\xe31I\x08!\xbfcY\x96\xdb\xedVm\
2700 \xcf\x1a\xfeR\xcf\xae\xedj{\x16\xff\x1a\x00I\xdb\x86\xa7g\xa2\x94\xc2\x0e\
2701 \x05\xb6n\xb5}\xbf\xdf%I\xb2=\x17>\xb9$c\x8c\xa4eY\x80OS\x16bnhr\xec\xe5\x00\
2702 \x00\x00\x00IEND\xaeB`\x82'
2703
2704 def getMCBitmap():
2705     return BitmapFromImage(getMCImage())
2706
2707 def getMCImage():
2708     stream = cStringIO.StringIO(getMCData())
2709     return ImageFromStream(stream)
2710
2711 index.append('MC')
2712 catalog['MC'] = ImageClass()
2713 catalog['MC'].getData = getMCData
2714 catalog['MC'].getImage = getMCImage
2715 catalog['MC'].getBitmap = getMCBitmap
2716
2717
2718 #----------------------------------------------------------------------
2719 def getMDData():
2720     return \
2721 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2722 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2723 \x00\x01[IDAT(\x91=\x90\xbbjUa\x14\x84g\xef\xb3O4\xde@\x82\x10"^\xba\xe0\x1b\
2724 \xf8\x02\xc1\xc2ti\xa2\x82\x96\xb6\x01K[\x1b+\x1f@{\xb1\xb1\xb2\x8bh\xb0\xb1\
2725 \xb5\x13\xac\x04\x8d`$\xa2D\x0f\xc9?\xb3f,\xce6\xc3\xc7T\xb3f`uX\xdc\xc6\xb1\
2726 \x84\xfa\xb4\x86\x01\xf8\x05\x1b>\x05\x1b\x1fVa@\x18}\x00\xf0\xe8\xc9*\x802l\
2727 tK\x0f\x93\xe0,\xbb\xd4$\x07}\xa6W\xb6\x141%S\x1f\x9f=\x1f\x00 \xd8\xfd\xc1\
2728 \xaaT%\xfa\x82\xe9\xc1\xab\x97\xa7]\xbc\xb9>Kx\xf4\x99!C\x0e+\x17\x1b\xd0\
2729 \xc3(c\x9eV\x05\xa9\xbd\xdd\xbazi\xd6\x0e\xf9\xf5\xdb\xdf\xa4\x85\xcd#2\xd0C\
2730 p\xa0\x8a\xca\x94\x13\xee\xbc^<\xff\xb4]\x7f3\xdb\xd9^\x88\x9b\x1b\xddZ\xb5\
2731 \x16Q\xc0\x80\xb2\x14\xcd]NX\xd5\x9d\xb9\xd1b\xea{\x1f7S&C\xfe?\x80\xca&\xad\
2732 \x8a\xe8\xb8I\xdd\xc6\xdb\xc7\xa4\xef\\\xdbJ8\xa6IK\x06\x06\xc0\x92\xa9P.:i\
2733 \x9b\xb7\xd8\x8e\x1e\x94\xda\xdd{\x7fb\xa6)\xa2\xc9\xa8\xc6\x05\x16(\xcf+bf\
2734 \xf8y{\x83vK\xc7\xf8\xa49\x7fk\xb9\xc6\x05I^^\x9aJa\x19\x93\x15\xf8\xc2\xe4\
2735 \x1c{+\xf9\x8d\xc9\x89\x85\xcb\x95*W\xa1\xca@\x07\xbc\x00t\xcc\xfe\xfb\xfb\
2736 \xee\xe1C\xd8#\xef\xd6`\x8c\x00\xf8\x07p\xbadU\xf1\xb3\x17s\x00\x00\x00\x00I\
2737 END\xaeB`\x82'
2738
2739 def getMDBitmap():
2740     return BitmapFromImage(getMDImage())
2741
2742 def getMDImage():
2743     stream = cStringIO.StringIO(getMDData())
2744     return ImageFromStream(stream)
2745
2746 index.append('MD')
2747 catalog['MD'] = ImageClass()
2748 catalog['MD'].getData = getMDData
2749 catalog['MD'].getImage = getMDImage
2750 catalog['MD'].getBitmap = getMDBitmap
2751
2752
2753 #----------------------------------------------------------------------
2754 def getMGData():
2755     return \
2756 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2757 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2758 \x00\x01\x00IDAT(\x91u\x8e=NB\x01\x10\x84\xe7\xc9K\x88\tF\x12\n*\x1a\x1b.\
2759 \xe49<\x85\\\x88CXx\rD\x121\xa1\x90\x86\x9d\xd9Y\x8b\xf7\x83\xc6\xb8\xd9L\
2760 \xb6\xf8ff\x9b\xd3\xe9\x84al\xcf\x17\x8b\xfe\xfeg[\x00\xf3\xf9\x1c@U\x01\xc0\
2761 fS\xc7O\xa4\x1ai"\xdd\x90%\xd5\xa0\xe7\xed\xb6\xed\xf2z\x1a\xa8\xfd\x1e\x87C\
2762 \x91\xfd\x06\x8bQ\x11E6\xabU\xdfp\xa5\xab UDI=\xca\xa8`g\x00i\xa0\xb5}\xa5\
2763 \x0b\x15\xfa\x9b=\x1a0\x1a\xaa\xaa\xeb9Ny\x9e\x85\xc5"\xcd0iF1R\x9c\xde\xebe\
2764 |\xa9\xfa|<=\xf2\xfd+\xa2\x18\x93`2\x1cLF\x06\xcd\x87;\xbe^\xd0\xda\x1e\xe3\
2765 \xab*\x15\x17\x06\xcd_tRVN\x84\x8f\x1f/u:\xe6\rJf\xc8\x94SNhh\x18=\xcb\xdb\
2766 \xa5\xd3,\xca\xa2\xa9\x94J\x99\x99\x95\xe9D\xa0\xd9\xedv\xb6mK\xb2\xbd~^\xe3\
2767 \r0p\x03\x08\x10\x10\x80\x00\x03\x02f\xf8\x06$\xb0c\x1f\xc6\x92\xeb\xa7\x00\
2768 \x00\x00\x00IEND\xaeB`\x82'
2769
2770 def getMGBitmap():
2771     return BitmapFromImage(getMGImage())
2772
2773 def getMGImage():
2774     stream = cStringIO.StringIO(getMGData())
2775     return ImageFromStream(stream)
2776
2777 index.append('MG')
2778 catalog['MG'] = ImageClass()
2779 catalog['MG'].getData = getMGData
2780 catalog['MG'].getImage = getMGImage
2781 catalog['MG'].getBitmap = getMGBitmap
2782
2783
2784 #----------------------------------------------------------------------
2785 def getMKData():
2786     return \
2787 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2788 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2789 \x00\x01\x88IDAT(\x91=\xc9=H\x96a\x18\x86\xe1\xf3\xf5{\xdb\xc2\xa6\xa0"%\nB\
2790 \xfa\x01\r\x9cl\xa8\xad\xa1\x9f)\x88\x96\x9a\xac1j1\x82\xa0Q\xa7\x88\x86&\t\
2791 \x02\xa9)\xca\xad\xa2\xa5\xc1\x8a\xc8\xa1%,\xfb\xe1\xc3\xa1\xc0D\xf2\xd3\xba\
2792 \xaf\xfby\xae\x16\t\xce\xe98\xb1\xf1%\x0c\x86\xf2\xbf.\xea\xf2\x176\xa0\x07\
2793 \xbfa\x15VFX^\xa1e\x02n\xdf\xe0*~\\\x9b\x95J)\xceBd\xd3dg<\xfbB\xce\xf4V\xf9\
2794 BzHk\xa7\x9f\xb6L\xc2\x0e{t\x89\xf3\x85\x99\xe2w\xa2\x14/\xca\xad\xfcY\x0ey8\
2795 |9\xbc\xa0fz\xa0\xbe\xa2\x05\xfc\xd3\xdc+\xec+>&\xb6\x15?\x0b\xcf\xa7\x91\t\
2796 \x9f\x08\x1f\x90\'\xc3o\xc4\xa0*\xb4u\x94f\xb0\xf0\'\xbd\x98,\xa4\x0f\xcaG\
2797 \xe4Q\xb9\xca\xcb\xe1_\xe1)y=\xbcK\x0c\x89\x17\xb4\xbc\x06\x8a\xd7\xe5\xb5\
2798 \xe4{\xfa\xbdLxL\xb6\xfc!\xdc\x93o\x86\xf7\x86\xfbE\x7f\xd6\xeb\xb4\x1c\xc5\
2799 \x17\xd3\x1f\xd3?\x82\x8d\xf4\x90\xdc\t\xcf\xc9\x0e\x7f\x93\xd7\xc3\x8fd\x87\
2800 \xb7\xab9\xacz\x87\xb6\xce\xd1\x8c\xc8_\x83\x81\xf4\xd9\xf0\x17\xf9IX\xb2\
2801 \xe5\x97\xe1\x93\xf2\x95\xf0\x031\x9f^\xcd\x84\xb6B\xa7?=.\x0e\xc9\xd3\xf2\
2802 \xf3p\x84\x87\xe5-\xe1\x87\xf2}\xf9xxJ\xbc-\xcc\x16\xa0\xad\xa7\xe8\x9bH\xba\
2803 ;}W,\x15v\x0b\xa9\xd9/\xfa\x92=B\xc9\xa7\xe4V\xe1Z\xe1L\xa9\x034\xbd\x1e\xf5\
2804 \x1cu\x96\n\x15\x80\nu\x8eZ\xa9c\x9b\xb8\xb9:\xb0\xc0?\xef\x8fD\x87?\xdeS\
2805 \xdf\x00\x00\x00\x00IEND\xaeB`\x82'
2806
2807 def getMKBitmap():
2808     return BitmapFromImage(getMKImage())
2809
2810 def getMKImage():
2811     stream = cStringIO.StringIO(getMKData())
2812     return ImageFromStream(stream)
2813
2814 index.append('MK')
2815 catalog['MK'] = ImageClass()
2816 catalog['MK'].getData = getMKData
2817 catalog['MK'].getImage = getMKImage
2818 catalog['MK'].getBitmap = getMKBitmap
2819
2820
2821 #----------------------------------------------------------------------
2822 def getMMData():
2823     return \
2824 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2825 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2826 \x00\x01\x17IDAT(\x91m\x91\xb1.DQ\x10\x86\xbfs]\x8bH\xb4(\xb6PP\xf1 \x1eE\
2827 \xaf\xdd\x87\xd9\x9e\xc6\x13\xe8\xc4;\x08\xc9\xb6"\xe2b\xaf;\xff\x9c3\x8a\
2828 \xc3\x8dE2\x99f\xfe\xef\x9f\x7f2\tn\xc0\x01\x98\x80A\x81\x16:qZ\xe0o\xb5\xe0\
2829 \xb3\xd9\xc1\xee\xde\xe4\xe4x\xf3\xe3#\xae\xaf\xbb\xbeO)+\xf9\xd9\x9a{#\x85{\
2830 |\xf7\xb7\xab\xab\x16X_o\x8e\x0e7\xa6\xd3I)\xf4\xfd\xf6|\xfe\x8c,t\x1fR\x98B\
2831 \x16f!\xa5\xe9\xb4n\xa0\x94\x80\x88H\x11\xa5D\x98\x95\xe4\xe5K*\x0bS\x05\x90\
2832 *\xd0\xf4\x037\xb7\xbd\x89\xf7e\xbe\xb8|\x91\x1aT\xc2l\xf4\x1e\x01\xea}1\x0c\
2833 w\x0f\xc3\xe3\xe2\xb5\xeb|\xf9\x9c\x93Q\xa4\x15u\x05\xdc\x0b\xb4O\x9cn\xe5\
2834 \xf3\xdc/J\'$\xa4\x90\x1a\xeb\xc3\x86\xd1\xfb\xeb\x86\x1ai\x07\x92\x96a\xaf\
2835 \xb8\xff\x1c\xffR\xe3\x1e\xee\x0em\x815\xf7\xf8\xf6\x1e\x03\xac`.<\x933\x15h\
2836 \xe4\xec\xef\x87\x84g\\HI\xc2\x9d\xda\xdd\xc9\xb9V\x81\xf4\xbe\xfaH\xfe\xfb\
2837 \xee8\x02>\x013\xecV\x12\x92s\xba\xce\x00\x00\x00\x00IEND\xaeB`\x82'
2838
2839 def getMMBitmap():
2840     return BitmapFromImage(getMMImage())
2841
2842 def getMMImage():
2843     stream = cStringIO.StringIO(getMMData())
2844     return ImageFromStream(stream)
2845
2846 index.append('MM')
2847 catalog['MM'] = ImageClass()
2848 catalog['MM'].getData = getMMData
2849 catalog['MM'].getImage = getMMImage
2850 catalog['MM'].getBitmap = getMMBitmap
2851
2852
2853 #----------------------------------------------------------------------
2854 def getMNData():
2855     return \
2856 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2857 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2858 \x00\x01\x1eIDAT(\x91]\x91\xb1j\x95A\x14\x84\xbf\xfd\xef\x1f\x14\xb1\x88$\
2859 \x85Q\xd2\x88\x92w\xc8;X\x85@\n\xdf$\xf8 \xbeF^\xc0\xde\xd6\xc2\xc2JDA\x10A\
2860 \xbc\t\xc9\xce\xecN\x8a\xfdo\xee\xc5\xc3\x14{\x0e3g\xe6\xb0%l\xab\xc3\x8a_p\
2861 \xb8\xe9:\xdc\\\xf3\xaco\x9a\x0e3\xc0\xe5%\xa7\xe4S/\xb7\xfd}\x7f\xfaO\xa5\
2862 \xb5\xd8\xc5^\xa1\xc7{~\x17)v\xa4\xf5\xd5\xd5\x0c@r\xf4\x83\xdf\x8d?\xed\xbb\
2863 \xdb_GZ\x90\xda\xbb\xbe\xa6\xd6H\xe5\xf8\xb8\xc3\x04\xe4m\xd8o\\\xb4H2\xb5F\
2864 \x8a\xea\xa0\xf5\xd4\xba@\xea0w(\x1f\x1bo\x9c/f\xb2o\x97\xddC\x96\x9a\x07)\
2865 \x12\xc3\x81\xf3\x16\x943\xe5P\xda\xae{\xd0lF\xf6rt\x8a\xf3\xda\x99+\xb2\xd4\
2866 \x07u\xb0\xd9q(\xdbH]q\x05\xa7\xd6Zsw\xb7M\xc5p\x90\xb0c{\x08V\xcd\xf9)\x1e)\
2867 \xd6\x7fy\x16\x81\x85\x1b\xad1\x04\xd3\x07\xb3>\xca,h/^NO\x84Tl$\x8a\xa7\xe2\
2868 W\xb46\xd0\xa1\\\xef\xfcb\x87\x03>\xc3\xf3\x9d\xc1\xfa\x1b'\xe35\xea\x1e\x9e\
2869 \x19N\x12\xd7\xb1\x80\xd6\x00\x00\x00\x00IEND\xaeB`\x82"
2870
2871 def getMNBitmap():
2872     return BitmapFromImage(getMNImage())
2873
2874 def getMNImage():
2875     stream = cStringIO.StringIO(getMNData())
2876     return ImageFromStream(stream)
2877
2878 index.append('MN')
2879 catalog['MN'] = ImageClass()
2880 catalog['MN'].getData = getMNData
2881 catalog['MN'].getImage = getMNImage
2882 catalog['MN'].getBitmap = getMNBitmap
2883
2884
2885 #----------------------------------------------------------------------
2886 def getMOData():
2887     return \
2888 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2889 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2890 \x00\x01\x8fIDAT(\x91M\x911kSq\x14\xc5\xcf{\xfe\t\x94\x17i\xea\x12\x1a\x89b&\
2891 [l\xd5\xa5K\xa9\x93\xfd\x08\xdd\x04A\x14AA\x04\xa3\x82\xdd\xfc\x06\xea\xe4\
2892 \xecj\x87v\xe8\xe4"H\xc1I\x17W\xa1j\xea\x10H\xa0\xe4\x91\xf7\xee=\xf7^\x87\
2893 \x18\xe8\x19~\x9c\xe5\xc0\x81_\x867@\x85\xffq\x80s\xca\xbc\xcc\xfa\x8c\t\t\
2894 \x13\xecn\xef\x02\xf0p\x0f\xb70\xd2\xb2\x9c\x00\'5\x19\xaaN\xba\xaaSM\x0f\
2895 \xde\x1f$$\x00\xf1\xa7\x1cX\x98\x99yh\x91\xccB\xef\xb6\xb3w\xc7\xe5\x84zZ\
2896 \x8b\x84\xa8i\xb7\xd9\x85#\x87\xc3=\xcc\x8dn\x1ez\xaf\x93\x97*E\xba\xf4\xb9\
2897 \xbc)ND\xfd\xb4\x0b\xa1\x08EM!\xc8\x01\x18\x8cA\x9aF\xf0\xc3\xdfr\\\xf3\xf6\
2898 \xc5\xed\xfe\xfa\x0b\xb1\x82.o\x7fO\x84"&\xea\xb3\x01A75U\xd7;m\xac\xb6\xb6\
2899 \x1e\\\xbd\xbf\xdaZA\xc4\xb3\xf5\'\x0fW^\x8d+\xbc\xbc\x9c\x8b\t\x8d \xce\xe1\
2900 \x166z\x1b\xa3z$._\xc7\xf2\xf8\xda\xa3\xcd\xf6f#o\x9c\x94\'\xd7/\xdc8\xdfh.5\
2901 Z\xaf\x7f|\xd2\xd0\xc5\xc6\xe2\xe0\xcb \x81\xd0P1\xa1SM\xfaG\xfd\x85\xb4P\
2902 \xb3\x9er\x9a\xb24\xaaF\xc3\xe9P]\xe94\'\x88\x04\x82\xc6\xd9%5\x9dj\xb5se\
2903 \xa7St\xd6\x96\xd6\x0e\x7f\x1d~\x1b~\xdf\xfb\xf9\x91\xa1t\xa3\x1b\x88\x84\n\
2904 \xea\\.\x96\xd5\x94n\xa4\xee\x1f\xef\xbb;\x9d\x95Ut\xf6Z=3\xb30s\x83 \xc3s\
2905 \xe0t.R\xe6R\xab3\xa6\xe5\x8c\xfe&\xfe\x01\xbfA>\xd1U\xf8Jr\x00\x00\x00\x00I\
2906 END\xaeB`\x82'
2907
2908 def getMOBitmap():
2909     return BitmapFromImage(getMOImage())
2910
2911 def getMOImage():
2912     stream = cStringIO.StringIO(getMOData())
2913     return ImageFromStream(stream)
2914
2915 index.append('MO')
2916 catalog['MO'] = ImageClass()
2917 catalog['MO'].getData = getMOData
2918 catalog['MO'].getImage = getMOImage
2919 catalog['MO'].getBitmap = getMOBitmap
2920
2921
2922 #----------------------------------------------------------------------
2923 def getMTData():
2924     return \
2925 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2926 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2927 \x00\x00\xefIDAT(\x91m\x91\xb1n\xc2P\x0cEo^\xdc\xad\xf4\x0b`b\xa1e@\x0ce\xe1\
2928 \xaf\xf84\xfe&R\xd521\x04\x06\xa2\xd0\xe5\xd9\xcf\xb7\xc3KB\xd2\xf6\xca\xb2<\
2929 \xdcsm\xc9E\xd34pG\x08\x18\xc9\xaf\xd7\xe7\xe5\xd2\x81\xbf%"\xf2$RU\xd5z\xfd\
2930 \x86"\x00 \x01\x11\x1e\x0ee\xdb\x06U\x9a\xb1\xef\xf7\xe3Q\xdc\xec\xe3\xeb\
2931 \xb3>\x9fMu\xb3\xdd\x92\x04\xc0\x94x:\xf1vcTjd\x8cT-\x16\x0b\x07$\x88\xacV\
2932 \xaf\xed\xfd\xfb\xe1&\xe9\xce\x98}\x91Q3\x00U\x07\xc4\xdd\x11\xc2\xfbnG\x12\
2933 \x04\xc1N\xaa=\xf3\x00\xd0\x01\xe8\\\xc3@r\xe2\xce\x80Y\xb7\xa1sL\xf2{`\xb4\
2934 \xa1\xc8\'\xfd\x1f\xef\x1c|C<\xcdl|\xd2\x04\xa0O\xe2Ma\t)a\xd80\xf4\xac\xa2,\
2935 1\x9fc6\x83\x19\xcc\x90R.\x07\x8a\xcb\xe5bf\xde\xab\x9b\xeb\xfae\xbf\xff\xf5\
2936 \xe3\xac\x1f5\xa6Z\xed\x19\x00\xa0J\x00\x00\x00\x00IEND\xaeB`\x82'
2937
2938 def getMTBitmap():
2939     return BitmapFromImage(getMTImage())
2940
2941 def getMTImage():
2942     stream = cStringIO.StringIO(getMTData())
2943     return ImageFromStream(stream)
2944
2945 index.append('MT')
2946 catalog['MT'] = ImageClass()
2947 catalog['MT'].getData = getMTData
2948 catalog['MT'].getImage = getMTImage
2949 catalog['MT'].getBitmap = getMTBitmap
2950
2951
2952 #----------------------------------------------------------------------
2953 def getMXData():
2954     return \
2955 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2956 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2957 \x00\x01pIDAT(\x91E\x90A\x8b\xcdq\x18\x85\xcf\xff7\xff\xb9MHw\xee4\x84fjV\
2958 \x94\x05\x1b\x1b\xba\x1b\xb3\xe1#H\xf2\x05,|\x05\x0b\x0b\x1bek\xe1\x0b\xd8+\
2959 \x16b\xa1\xa4\xc4\x94\r\xe9R2e\xa2\xa4\x1b\xd7\xfb\x9e\xf7\x1c\x8b\xff\x94g\
2960 \xf1\xecNO\x9d\x0e\xd7\x0f\xa2\xf5\x18 \xbf\xdd\x9d54I\x00$q\xb1\xd8\xdb\xda\
2961 \x02@@\x80\x80\x1eh\xb7\xae\xde\x01:\xa9\xa2r\xb2\xba\xd6\xba\x06\xd86\x00g.\
2962 \xdf\xb8\tYEg~xp\xbf\x07\x00c\xf7\xd7^\xa9\xfed\xd8F\xe7\xff\xc81\xfbl\xcb\
2963 \x99K\xc7\x8f\r\x05\xc9*\x89*\x8a\x86m\xcf\xde=\x93\xb4q\xea\xc2\x92\xad\x0c\
2964 H"\x1b\x93@\x83X\x16]\xac\xca\xa2\xed/\xef_~\xff\xf4\xf6\xe1\xbd\xdb\x1f\xdf\
2965 <6\xe0\x08e*RI\x01="Jb1\x8b\xac\xb2=\x1a\x1f\x99\xb7\xc3\x076O\x8fO\x9c\xb4d\
2966 R%\x91&\t4\xd0Te1\x8b\xa1\xb4\xfd\xf4\xf5\x8b\xaf+\x93\xd5\xb3g\x9e\xbcz.[\
2967 \x11\xca4\xd3L\x00\r\x04\xc5\xa1\x10\x19\x86/\x9e\xdb\xd6\xfc\x07\xab\xb6\
2968 \xcf_\xb2]\x91\xceT\xa4Y\x04z\x04\x8aC!\xa3hy2^\xbfr\xf9\xda\xfeI\x11\xce\
2969 \xb0a\x95K\xfb\x83\x14\x8f\x1eZ\xcb\xca\xdf\xf9\xb7\xeb:\x00\x83\x01t\xad-on\
2970 \x00\xb0,\xa6\x80\x0eS\x80\xc0\x02\x10\xf0\x13;\x8fvFmDR\x92\xa4\x98\xcfw\
2971 \xa7\xd3\x06\x10\x00\xd0\x80\x7f\xfa\xa3T\xf0\xfd[\xcfL\x00\x00\x00\x00IEND\
2972 \xaeB`\x82'
2973
2974 def getMXBitmap():
2975     return BitmapFromImage(getMXImage())
2976
2977 def getMXImage():
2978     stream = cStringIO.StringIO(getMXData())
2979     return ImageFromStream(stream)
2980
2981 index.append('MX')
2982 catalog['MX'] = ImageClass()
2983 catalog['MX'].getData = getMXData
2984 catalog['MX'].getImage = getMXImage
2985 catalog['MX'].getBitmap = getMXBitmap
2986
2987
2988 #----------------------------------------------------------------------
2989 def getMYData():
2990     return \
2991 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
2992 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
2993 \x00\x01\xa2IDAT(\x91M\x91?h\x14a\x10\xc5\xdf\x97o\xbd\xec\x99Ssb\x1a=\x0c\
2994 \x111\x8d\x04,\xec\x04\xb5\xf4*\xab\x80V\xa2\xbd\x1b,\x0cXZ\xa5\xb0\x11%""X\
2995 \xa4\x886\x86\x88\xd8DR]\xe0*\xff\x80\xc8\xa1\xb9;C\xbc\x8b\x9a\xc6?$\xee7\
2996 \xb3\xf3,v\xa3N\xf1\xf8\xcd\x14\x8f73\x0ehV\xcb\xaf\x17\xe7n\x01\xa8_\xbc\
2997 \xf63\x9d\x00\x0c\xb0&N\x0f\xe7\x04\xe8\x7f\xea\xaa\xe5\xfb\x9f:\x1e\xc0rc\
2998 \xfc\xf8\xf8Z\xa9\x94>}~\xe2C{\xff\xcc\xcd\x03\x83>#@3\xee\xd4\xaf^/\xba~u\
2999 \x118\xbf\xd2\xdcwrb\xa5\xb2{\x0b\x96\xd5\xcf\xf6\xa7^Nn^\xbe\x12#\xa5(%\x98\
3000 \x08C\xf0\xb5C\x1f\xe7\x1fG\x00\x00\xdb\xf8R9vd\xa0\x12\xeb\xd6\xb6\'3\x11\
3001 \x0c?\x98\x8d\xbd\x92F\x16\xe2\xbc?\x9aL\xb9!\x7f\xefk\xdf\x98\xf5g\xee\xd4/\
3002 M.\x83:\xfb\xe8\xd4\xab\xb7\x07\x1f\x96\xa6\xcbHM\xd5D\x18\x84*\xbeV{\xbf\
3003 \xb0\xe0\x80\xc6\xdd\xdbC\xe7\xce\xbc \xb3\xe4\xc6\x05Q\x86`"|\xf6d\xa4\xec\
3004 \x03\xc9b\x07\xc0y\xff\xbd\xddvM\xe0p2\x9dv\xd7 b*Ta\x10\x0b\x12\xcb\x0f\x17\
3005 \x0fR\xc4Dr\xdd5:\xfani\xc9I\xff\xb3\xdb\xb3\x97Y\x06\xa2\x08\x9b\x876+\xbc\
3006 \xcdH\x82tQ\xb4\xb9\xba\xeaZ\xc0H\x92h\xb7k"T\xa5\x88\xe5\x99D\x18\x02E,\x1f\
3007 fYil\xecM\xa3\xe1\xb6;\x9d\xa8Z-lv\xae\x0e\xb3\x7f\x1f\x00h\x06\x12\xc0\xb7V\
3008 +\n\x1b\xbd\xdf\xeb\xebff\xaa\xa6\xfa\x17T\xd5\xcc\x90\xf7\x9a\x83\r\x00\x7f\
3009 \x00\xba\x16Z\xd9\x8b\xc35\x87\x00\x00\x00\x00IEND\xaeB`\x82'
3010
3011 def getMYBitmap():
3012     return BitmapFromImage(getMYImage())
3013
3014 def getMYImage():
3015     stream = cStringIO.StringIO(getMYData())
3016     return ImageFromStream(stream)
3017
3018 index.append('MY')
3019 catalog['MY'] = ImageClass()
3020 catalog['MY'].getData = getMYData
3021 catalog['MY'].getImage = getMYImage
3022 catalog['MY'].getBitmap = getMYBitmap
3023
3024
3025 #----------------------------------------------------------------------
3026 def getMZData():
3027     return \
3028 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3029 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3030 \x00\x01\x85IDAT(\x91M\xc6=k\x93a\x18\xc5\xf1s7wbmm\xe9\xd2B\x84G-t\x14:\xfb\
3031 \x05\x04\xc1I\xd0M\xbbw\x13\x17Q\xac\x8e\x82\x8asqpr\x10q\t\x88/\x9f@:\xd5.\
3032 \xd5I\x17\x8bi\x92\xa21\x89\xe9}\xae\xeb\\\x0e\xf2\x80\xf0\xe7wNz\xb2\x8e[\
3033 \xd7\x80S\xc0\x14\x10`\xb5\xffWj3R\x00\xdf\x9e\xde\xed\xac\xe3\xc7\x92T\xe4\
3034 \xe1&w\x99\x85\x99\xccD\xba\x99H\x19\x9d\x9d\xedN\x06p\xae\x1f\x1b/\xbf?\xbf\
3035 \xe0;\xabN\xd2\xe5tR\xa4HgQ)^\xe8\xac\xe6+dd\x00\xa1XL\xbe\xf9\xde\xaf\xde\
3036 \xbf\xd9l\x9f\x8d\x88\x88P\xa8\x1eE\x84\xa4\x9c\xf3\xfe\xe9\xfd<\x01>\xcf\
3037 \xf9\xeae\xfb\xf3\xc2\xda[\x8f\xf6\x98\x9f\x91\x074\x92,\xa5\x904\xb2\x90du\
3038 \xa6\xea|\xe8\xcc\x14\xa0}1m\xbd^Y\xd8\x98\x8b49?\x1e\\\x19\xf5{\xa3^o\xd4;\
3039 \xfc\xd7\xf0\xb0;\xecv\x87\xdd\xc1x\x00 O\x81Wo\xfc\xe1\xf5\xc9\xd1\xbb\xd9\
3040 \xd9#\xff\xe8\xcdmC!\nACa\xa2\xa1X\xa25h-\x00\xe9\x18h\xdc\xd9\x8c\xdd\xaf\
3041 \x987=\xb8\xf7ki\xc1$D\x84\x14\x92B\x90\x14\x1eR\xa3y\xf2\xcb\xde\xdb\x0c\
3042 \x00}\x8b\x06q\x89h\xdd^\xfc]B%\xc4Z\x86J\x04\x11\x9eN\xac\xad\x1d|\xca\x02f\
3043 \x96\r7\xdaQ\x11SG\x10\xc1\x14\x04\x0c \x92!\x19\xe0\x08\xc7\xb1\xab\x8f4^\
3044 \x86\x1eC+\xd0O\xc8\x00\x83\x04\x19T \xd5\xdf \x00\x06\xb4\xf0\x17\x9ffI\x92\
3045 \x19^\x18d\x00\x00\x00\x00IEND\xaeB`\x82'
3046
3047 def getMZBitmap():
3048     return BitmapFromImage(getMZImage())
3049
3050 def getMZImage():
3051     stream = cStringIO.StringIO(getMZData())
3052     return ImageFromStream(stream)
3053
3054 index.append('MZ')
3055 catalog['MZ'] = ImageClass()
3056 catalog['MZ'].getData = getMZData
3057 catalog['MZ'].getImage = getMZImage
3058 catalog['MZ'].getBitmap = getMZBitmap
3059
3060
3061 #----------------------------------------------------------------------
3062 def getNGData():
3063     return \
3064 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3065 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3066 \x00\x01\x1eIDAT(\x91u\x91\xb1NUa\x10\x84\xbfs9\xe1\x9a@"\xb9\r\xa1\xa0\xa1\
3067 \xe1A\x88\xbd\x0f@m|\x01+\x1a+{K_\x83\x97\xe0!(h\xb4\xa1 \x91`r\xf2\xef\xcc\
3068 \xac\xc5\x89J N\xb1\xcd\xce\xe6\x9b\xc9N|\x85\x05\x80\x80\xb8\xfbpw\xb4\x7f\
3069 \x94\x04H\xf2\xb0<\x9c\x7f9G\x10\x1803\xf3\xc4\xd5\xbb\xabu\x9d\xce\xf1\xeex\
3070 \xbby\x03\xdd\xdd\xc0\xb6\xb6\x97\xef/EUT\xae\xebo\xd733\xd0\xdf\x7f\xfdpl;\
3071 \t\x9b\xfe+\xc7\xb7?oGF\xa5N\x0fO\t3!i\xc7\x8a\xe5\xeaW\x1a\x1e#\xa3\\\xe5b0\
3072 \x03\xc6j)R\xf4\xc2\x9ddx\x0c\x8fJU\xd6\x03\xa1\xb8\\\xb2\x145\xaf\x08\x1ak$\
3073 Y\x88\x19\xe1H\xd1\xc8\x90_\x12\xfeE\xeag\x84\xea\x1a\x1e\xb2\xca\xa3\xd3\
3074 \xfd\xact:\xc3\xa3\xba\x149\x7f\x08\xb2\xd6N\xf5\x9f\xd2\xeaR[1bf\xa1\xa2\
3075 \x93\x83\x93rI\x9e\xa6\tX\'\xb0\xb7\xd9;{{\xe6\xb6\xdb\x8e\x19L|\x82G\x10,\
3076 \xb0p\xf3\xf9f\xb7\xbf[?-\xe9\xfe\xe9\xfe\xe2\xe3\x05\x01@p\xc8o\xd3|v \xc0\
3077 \xdc6\xb7\x00\x00\x00\x00IEND\xaeB`\x82'
3078
3079 def getNGBitmap():
3080     return BitmapFromImage(getNGImage())
3081
3082 def getNGImage():
3083     stream = cStringIO.StringIO(getNGData())
3084     return ImageFromStream(stream)
3085
3086 index.append('NG')
3087 catalog['NG'] = ImageClass()
3088 catalog['NG'].getData = getNGData
3089 catalog['NG'].getImage = getNGImage
3090 catalog['NG'].getBitmap = getNGBitmap
3091
3092
3093 #----------------------------------------------------------------------
3094 def getNIData():
3095     return \
3096 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3097 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3098 \x00\x01;IDAT(\x91]Q\xb1jT\x01\x10\x9c\xbd{\x81\xdc)\x1c\xc1\x84\x08*i\x8c\
3099 \xadM\x04K\xfd\x824\xf9\x88\xb4\xf7\x05\x81\x14\xfe\x82\x95\x85\xa5 \x88U\
3100 \xc0_H\x93\xb46WY)A\x1fw\x9e\xbc\xdd\x99I\xf1\xee\xe0\xcea`a\x99e\x99\x99\
3101 \xc0\xd4\xe8\xb0\x82\x84\xc2\x9aB\t\xdd6\x81\x06\x1d.\xce\x00@\xb6\x1c\x14h\
3102 \x94LFi\x98\x1c\x94\\t\xca%\x7f\xbe\x9c7(\xc0\xf8\xd1\x9a\x02\x85\x92\x8bH9\
3103 \xb9\xd2e\xb9\xa3\x93~:\t\xfcU\xf3\xea\x04\xc7\xfb\xde\x1bA\x06\xd5\x9f\x99Z\
3104 R\x95\x1a\x17\xdd\x7f(\xf9`\x8c\xafo\x14$#\x02\x80m\x18\x86=\xff\x90\xf3V\
3105 \xcaf<\xf2\x83s\xaf\x11\x11m\xdb\x0ez\xb7\xab]?\xd9]\xcd^|\xff\xf2\xc7Lo\x02\
3106 \x90\xd4l\xaa\xb1\xba\x88\xb7G7|\xb6kl\xe9\xc3\x96\x14/\xdf\xe7\xf4u\xfc\\x\
3107 \xed\xd8%E\xfe\xa6\xb5\xd4\x84B\xd1e\x938|\x18\xef>\xfejn\xbf\xe9\xfa\xc9pv\
3108 \xe7$:\xf6\x99 5\xc9r\x96\xbb>S\xba\x88\xe7\x8f\x80OhPJ\x0c\x1eOPt\x12%$\x91\
3109 \x8c"R\x10\x91F1d\x97\x00(p\xba\xc0|]d\t\xff\xf0\x7f\xbb}\xe5)\x00\xd8\xc1=/\
3110 1b\xbb\xb0X\xc4#\x00\x00\x00\x00IEND\xaeB`\x82'
3111
3112 def getNIBitmap():
3113     return BitmapFromImage(getNIImage())
3114
3115 def getNIImage():
3116     stream = cStringIO.StringIO(getNIData())
3117     return ImageFromStream(stream)
3118
3119 index.append('NI')
3120 catalog['NI'] = ImageClass()
3121 catalog['NI'].getData = getNIData
3122 catalog['NI'].getImage = getNIImage
3123 catalog['NI'].getBitmap = getNIBitmap
3124
3125
3126 #----------------------------------------------------------------------
3127 def getNLData():
3128     return \
3129 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3130 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3131 \x00\x00\xfdIDAT(\x91}\x8e\xcd*\x85a\x14\x85\xd7\xabOR\xe7\x8c$\t\xe1\x12\\\
3132 \x81\xcb2\x90\x0b025t\r\xe6\xee\xe5$18EG\x94\xde\xbd~\x0c>\x0e\n\xab\xdd\xea\
3133 i\xb7\xf6j\xb7\xe0K\xfe\xc9\xbfN\x0b\x80\xd3s\x00\xb1aA\n\r1\x14\xc8\x14C\
3134 \xa5j\xf4\x97\xeb\xab\x01\x00\xc0\xdc=@\x82\x9c"T)\xa6\x98\xaat\xa6zz\xa5z\
3135 \xdb\xdb10`\xf3(\xbb\xfbX\x9b@\x0e\t)T\xc8\x90\x1f0\x1e\x93\xd8\xda4\xd0\x16\
3136 \x8b\xc5t:\x05\x90\x04A\x90\xbf\xd4Z\x9b\xcdf\x83\xed1\x9dd\t\xbf\n\xad\x91\
3137 \x1c\xbc\x0c\xfd\xdf\x9f\xb4\x04@\xc3\xe1\xc5\xc9\xd9\xf1\xed\xfc\xb5h\xca\
3138 \x9d*\xb9\xa8\xe2\xd2M\xba\xa4\x83\xad\xc9\xcd\xf9\xe5\x80\xfb\xe7\xa7\xd7>_\
3139 \xbc\x15]r\xa7{\xa9\xa8N/\x9d4\xed\xc9\xfa*\xf08\xa0\xbb\xe4\xed\x8d\xf5\xb1\
3140 \x89r\xc9\xa5\xb1\xd5\xa4\xe8H\x96-\x8d/\xe1\x14\xe8@\x07\xf8\r\xf8mC\xc0\
3141 \x9f\xbe\xf2\x0e\xd9$jsT\xa0\xbcG\x00\x00\x00\x00IEND\xaeB`\x82'
3142
3143 def getNLBitmap():
3144     return BitmapFromImage(getNLImage())
3145
3146 def getNLImage():
3147     stream = cStringIO.StringIO(getNLData())
3148     return ImageFromStream(stream)
3149
3150 index.append('NL')
3151 catalog['NL'] = ImageClass()
3152 catalog['NL'].getData = getNLData
3153 catalog['NL'].getImage = getNLImage
3154 catalog['NL'].getBitmap = getNLBitmap
3155
3156
3157 #----------------------------------------------------------------------
3158 def getNOData():
3159     return \
3160 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3161 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3162 \x00\x01ZIDAT(\x91m\x91\xb1jTa\x14\x84\xe7\xbf\xf7\xdaXH\x96\xd5b\x93\xac\
3163 \x84\xd8X\x88\xa5\x8d\xe0K\xd8Y\x88`\x17L\x11\xb1\x93<\x81\x81<@\x1a\x8b\xb4\
3164 \xc2\x92\xa7\x10\x02*B\xec\x8c+h\x88E\xb8\x10\xd2\xf8\xcf\x9c3\x16w\x17,2\
3165 \xc5p\x8a\xc3\x9c3|\xe5\'\x16\xbak\xdf|\xf6\xf5\xea\xf0\xc1\xbcm\x13H\x00\
3166 \xc00\xe8?\xef\x00\x8cv\xdf\x02\xb0\xbd\xf7b\xb5\x942~\xbd\xe3\x10$K\x16MYL\
3167 \xca\xe4\xf7\xd9Q\x07\x00p\xfe\xfa\r\xe0O/\xdb\x9a\xcf-\x82L\xd2\xa4Y\xb3VW\
3168 \xb6\xd3\xe9\xe2\x02\xc2V\x00\x88L\x00V5\xe5J\xb3\x9a5I\xd7\x9adC\n\xe8\xd6#\
3169 J)\xc3K\n\xdb^\xf90\xf3u*\xa5\xdc\xbf\xbc,\xed\xd3\xcf\xfb/\xd7\xce{FZ\xb22\
3170 \x15f\xa4\xc2T*\x92a\xc9\x8c\\\x1d\xdd8xu\\"b\x887\xfc\xe6\xfd\xd9\xbb\xe7\
3171 \x93k\xe3m7M\xd3\xf7}w\xda\xb6\xb7\xb7\xb7t\xfacev\xc4\xb0\xed\x8b\'\x8f\xb3\
3172 2I\xb0f\xe5\xa2\x06\xd5\xdd\xdb<9\xfe\xd4%`\xca\xa4mF\xda\xce\xbf\xc3F5\xe9\
3173 \xcad5\x99\x11P\x08\xe8\x12\xb0\xd4L&\xb6\xef\xdc\xea\x00\xb4\xeb\xd3&\x98\
3174 \x14\xc4\xa4Z)#\x10\x91\x11\x00\xca\xc9\x12\xe1F\xdf\x8f\x1e~\xbc\xf8\xf2\
3175 \xe8\xdbx\xac%\xe3\x010\x96\x0e\xe0\x1f\xf4\x9eZ\x92\xf2p\xb7\x17\x00\x00\
3176 \x00\x00IEND\xaeB`\x82'
3177
3178 def getNOBitmap():
3179     return BitmapFromImage(getNOImage())
3180
3181 def getNOImage():
3182     stream = cStringIO.StringIO(getNOData())
3183     return ImageFromStream(stream)
3184
3185 index.append('NO')
3186 catalog['NO'] = ImageClass()
3187 catalog['NO'].getData = getNOData
3188 catalog['NO'].getImage = getNOImage
3189 catalog['NO'].getBitmap = getNOBitmap
3190
3191
3192 #----------------------------------------------------------------------
3193 def getNPData():
3194     return \
3195 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x06\
3196 \x00\x00\x00v\xe2\r9\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
3197 \x017IDAT(\x91\x95\x90\xc1+\x83q\x1c\xc6?\xef\x10k\xd9f-i\xc4E\xad\xc5\x8988\
3198 +\xc9EJN\x8e\xfe\x8c\xe5\xe0\xb2R\xeer\x94\x1c\x9c\x948Y8 \x07\xb9*5\x8c\xd5\
3199 \xbb\xc2\xcbjz_\xef~\x8f\x9b63m\x9f\xdbsx>=\xdf\xafE\x15c\xa9K\xf3\xd2\xd9\r\
3200 H\x0f7\xa3m\xb4\xcax\xea\\\x0e\xa8`Yf`\xe4\xa4\xd4L'P\x1d*\xa6\x84\x0f\xc4\
3201 \xf3y\xebv7\x16\xeaO\xed\x97[\x12\x18\xf3A\xd4q\x90\xeb\xd2\x1e\x0cZ\xb9\xe3\
3202 \x89`bx\xcboZ\xe0W^)g\xb3\x04\xc2a\x02\x91\x08\xf9D\x82\xc3\xbb\x95\xb6\xbe\
3203 \xc1U5\x12X\xd5!9\xb4\xa6\xa3\x874\x06\x98\x9f>\xe0\xdd~\xa4\xec\xd8H.2\x1eo\
3204 \x85\r\xeb\xb7\xa0\xbd:|Ul< \x9e\xc9\x90\xf5\xaeIn\x96x{^\xaf+5d\xb0oQ\xc5tZ\
3205 \xee\xfd\xbd\xdc\\N\xb9\xb99\x85{\x97\x1b\xce\x87\xba\x1f\xd8T\x1c\x07|\x1f|\
3206 \x9f\x8eX\x8c\x9d\xe26\xa1\xe8\xcc\xbf\x92\x1fzc\x93\xba\x00=--)\xbf\xb0\xa0\
3207 3\xd0)h\x0f\xd4\xd5=\xf5\xa7\xa4\xe6\xbeP\xcf\xac\xa4/\x90\x87d\x90\x0c\xc8 \
3208 \x01\x12\x92\xf0>\xafj:\xdf\xf3\xfb\x91\xc3\xc4\xf4\x81+\x00\x00\x00\x00IEND\
3209 \xaeB`\x82"
3210
3211 def getNPBitmap():
3212     return BitmapFromImage(getNPImage())
3213
3214 def getNPImage():
3215     stream = cStringIO.StringIO(getNPData())
3216     return ImageFromStream(stream)
3217
3218 index.append('NP')
3219 catalog['NP'] = ImageClass()
3220 catalog['NP'].getData = getNPData
3221 catalog['NP'].getImage = getNPImage
3222 catalog['NP'].getBitmap = getNPBitmap
3223
3224
3225 #----------------------------------------------------------------------
3226 def getNRData():
3227     return \
3228 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3229 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3230 \x00\x01QIDAT(\x91U\x911KW\x01\x14\xc5\xcf\xd37H\x10\xa2A\xf8\x07\x83tr\x08Z\
3231 Z\x84\xa4/\xd0\x10\xb4\x06\xad\x0emM-\xae\xba\tN\xe1g\x90>D\xe4\xec\xe0\xe4\
3232 \x10!%\x94\x11\x82b\xef\xbd{\xcf9\xd7\xe1\xf5\x97<\x9c\xe1\xc2\xfd]\xb8\x9c\
3233 \xd3`\xf2\x16\xc4?\xd9\x08\x82D\x10\n\x80@\xfc\xe7\x1e`\x0bbk\xe7\r\x00\xcb.\
3234 H\x92MY6iJI\x93J)\xa9O\xdb\x1fZ\x00\xa8:\xfb})\x97$j\\;\xa9[G2\xa9\xe5\x87\
3235 \xf3@\xb40$PEY2\xe9\x90I'=\xa5\x95TP\x99\x02\xa2\xc5=\xce\xcep\x16Y\x8d\nU%\
3236 \xcb\x92dI\xe4\xf8\xa0d\xd1E\xe0o\xfb\xed\xe3\xe7\xc5\xb5\x179\x9cS\x84\xd5@\
3237 e\x96YN\x9be\xdaY\xa6\xcdvn\xe9dQ\xed\xca\xabg\xefw'\xdf\x7f\xce\xad?ytx|zy=\
3238 D*\x93!e*(\x92\x99J\xea\xf1d\xe1\xcb>f\x90\xcc\xf4\xc6\xd3\xd5w\xaf\x9foo\
3239 \xbe\x94\x9b\xaeg\x97\xd5\x0f\xee\xc3\xfd\xa0np\x17\xee\xc2A\x00h\x81 utr\
3240 \xf6\xeb\xcf\xd5\xd7\x1f\xe7}?\xe44D\x92\x94HQ\x92mk<\xe8\x93\xae\x06{\x07\
3241 \x87\x17W\xdd\xd2\x83\xfb\x94\x93\x9e\xa2\xa6\xc4\x11\x97\x004\xc0\xfa\xdd:\
3242 \xc7Fo\xe7\xc2]\xdd\x00\x04-r\xbe9\x02\x8d\x9c\x00\x00\x00\x00IEND\xaeB`\x82\
3243 "
3244
3245 def getNRBitmap():
3246     return BitmapFromImage(getNRImage())
3247
3248 def getNRImage():
3249     stream = cStringIO.StringIO(getNRData())
3250     return ImageFromStream(stream)
3251
3252 index.append('NR')
3253 catalog['NR'] = ImageClass()
3254 catalog['NR'].getData = getNRData
3255 catalog['NR'].getImage = getNRImage
3256 catalog['NR'].getBitmap = getNRBitmap
3257
3258
3259 #----------------------------------------------------------------------
3260 def getNZData():
3261     return \
3262 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3263 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3264 \x00\x01\xd8IDAT(\x91M\x91=kSa\x18\x86\xef\x9c\x9c$=\x874\xcdI\x93\xc6\x10k\
3265 \xc1F1\x01\xb1\xfd\x01\x16\xc1I\xa5\xa0\xe8hGqp\x10W\x1d\xa4\x83\xbbc\xa1\
3266 \x88\xd8\x82\xe8"*b\x05\x15,:\xe8P\xe8\x97E\x07\xfbA\xd3\xd0\x98\xc4\xc6\xa6\
3267 \xc9I\xde\xe7y\xde\xd7! \xddn.\xaek\xba\x03\x9f\xefL\xbe\xdbO>x\xb4|?\xb5\
3268 \x1a\xb6\xac{\xe5#7\x86\xf4\xc5s\'\xaf<)\x01-\x80\x01\x06\xda\x80\x02\x14`\
3269 \x07N\xa7o\xcd=\x9f\xe0d\xba\xbd\xf6\x1d~\x0b\x99l,\x95x\xb3P]\\\xdf\'\xd2\
3270 \xcc\xfa\xbc[\xfe\xd0\xe8o\xf8Ll^?\x9e\xb4g\xac\x17\xc1\xd5B\xe4o-\xb4W7~;\
3271 \xe4\xc5\xdb\xa4\xcf\xfa\xeaUm\xd4\'3\xee\x14s\xcd\xdfu?>\xb5\x93\x1c\xcc\
3272 \xc6\x01\xb6^\xba#\x94\xcb\x87\x87s\x14K\xe8\xa3C=#g\x0e\x12\x99\xa5\xd0\xb1\
3273 \x0e\x1bE\xf2\xac\x96\xfaT\xef\x9b*\rLxE#\x02(\xab:v9\x10\x8d=\xddp\xb6\x02\
3274 \xde\x16\xb93\xf5A;\x9f\xaf\x87cm%w\xbd\xb5\xa4\x83\xd9\xca\xc05w\xf3\x84\
3275 \xa9]\x88\x14\x01\x15<\xd5\xf0v\x9d\xd4\x97\xe5?\xbe\xdfY\xaf\xd2\xc7o;+\xbb\
3276 \x92\xea\x91\xc52\x8f;\xdb\x05S\x99\xdb\xf3\x16\x1an\xbfn\xbe5\xc3\xdb?\xde\
3277 \xdb\xb3\xbf\xec\xdb\xc18\xc7\xf0\x95{\x99\x84\xfa\xf8g\x85VJ\xa2\xc8\xdc\
3278 \xdc,(b"V$\xd3~\xf6\xb8#\x80\xb2\x00&\xd2J4\x93\x10\x89R\xbaCF\x91\xeezDZ\
3279 \x91\\\x8fn0\x89\xb0\x06\x94\r0\xb3\x90\x12b\xe9J\x8a\x84\x94\xa8n\xcf\xfc0\
3280 \xbd\xe4\xe9f\xa7\xb73/\xa3\xdd\xa0El2\xe9(\x910\x0b\xb3&\x16ba\x12b\xcd,\
3281 \xd3\xa1\xb1K\x91\xe2\xbcN\x8b\x18@\x02\xc0U\xe0\xe0\xd0\x97\n\xe0C\xfb?a@\
3282 \x03\xee?\xf8\x90:\xacV7\nv\x00\x00\x00\x00IEND\xaeB`\x82'
3283
3284 def getNZBitmap():
3285     return BitmapFromImage(getNZImage())
3286
3287 def getNZImage():
3288     stream = cStringIO.StringIO(getNZData())
3289     return ImageFromStream(stream)
3290
3291 index.append('NZ')
3292 catalog['NZ'] = ImageClass()
3293 catalog['NZ'].getData = getNZData
3294 catalog['NZ'].getImage = getNZImage
3295 catalog['NZ'].getBitmap = getNZBitmap
3296
3297
3298 #----------------------------------------------------------------------
3299 def getOMData():
3300     return \
3301 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3302 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3303 \x00\x01\x1aIDAT(\x91u\x8d=JC\x01\x10\x84\xe7\xc5\xa7\x82\xf8\xd3\t\x82\x10\
3304 \x88\x1e\xc0V\xd0cx\x00=\x83\xa4N\xe7il\xd3\xc6\x1c\xc0\xdc\xc0&E,M\x1a\xc1\
3305 \x9d\xd9Y\x8b\x17\xffP\xbfbf\x96\x9de\x9b\t~p\xf6\xb2\x02l\x1b\x9d\xfd\xa2\
3306 \x05p\xb9\\\xbe\xcef;\xe7\xe7\xcf\xa3\xd1\xc1\xc1^\x15\x80\xaaO\xfb\xc6b\xb1\
3307 h\x01\xe4j\xb5{q\xf1\xf6\xf4\x14\xf3\xf9\x9f\xbd\x8e\xa6i$\xf5\x00l\x1c\x1e.\
3308 \xc7\xe3\xad\xc1\xc0\xe4\x7f\xed\x0e\xdb\xcd\x048\x1d\x0e\xdf\xe6\xf3\x92\
3309 \x8aJ\xb1H\x93\x0e\x16\xc3\x11&+\xc2\xe4v\xbf\xff0\x9d\xb6\x06JYdI\xa6 "\x02\
3310 $\xc8\x8a\xa8N\xbb \x01h\x05T\xaa$3L\xf5\xc8b \xd8D4\\ku\x99\xec\xad\x0fHGX\
3311 \xaa\x88\x9b[F\x06\x93\xf4:\x84\x83\xa6R\'\xfbz\xbcC\x0b\xc0\x92I\x93EF\xc6W\
3312 /\x19I:d\xca\xa9Lx\xfdA\x9bGGEZy\xbcC\x9aL\xca\xa2)K\xa5\xccLg"!4\xf7\x80\
3313 \x00\x01\x06\x04\\_\x01\x01\x08x\x05\x0c\xf8c\xec\xd6\xc0;\xbc\xecyx\xe0\xb6\
3314 \xdf\x86\x00\x00\x00\x00IEND\xaeB`\x82'
3315
3316 def getOMBitmap():
3317     return BitmapFromImage(getOMImage())
3318
3319 def getOMImage():
3320     stream = cStringIO.StringIO(getOMData())
3321     return ImageFromStream(stream)
3322
3323 index.append('OM')
3324 catalog['OM'] = ImageClass()
3325 catalog['OM'].getData = getOMData
3326 catalog['OM'].getImage = getOMImage
3327 catalog['OM'].getBitmap = getOMBitmap
3328
3329
3330 #----------------------------------------------------------------------
3331 def getPAData():
3332     return \
3333 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3334 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3335 \x00\x01MIDAT(\x91U\x90\xbdJ\xdcQ\x14\xc4\xe7^\xff)\x02q\x9b\x85\x85\x08bae\
3336 \xc0\xd6V\x10,\xac\xed\xf3\x0c\xb6\xb1L-b\xe9C\x04\x05{!>\x81\x95l\x13\x88\
3337 \x85Z(\x06w\xd5\xe0\x9e\x8f\x19\x8b\xeb.:\x1c\x0eS\xfc\xceg\x19\x8dFx\'\x12\
3338 \x00I\xa2\xdf\'\xd0"\xa6\x86@\x07\xa0\xd7\xeb\x01\xf8\xf7_$\xfa\xf3\x90\x00\
3339 \xc8vv\xf8\xfc,wE\xcc\xf2\xdd\xc9I\xd7\x1a\xdf\x8c\xf5\xeb<\x9f&\xfa\xbeV\
3340 \x17zER\xfe\xbd\xe4\xe3X\xe6t\x93\x99\xdc\xeb\xe2b\xb4\t\x92\xbe\xcecu\x01O\
3341 \x93\xd2hI\x8d\xa3\x9b\xcc[\x01\xdd\xdfVjZ_\xae\x104\xd3hL7\x9a\xc9]ft\x9fs\
3342 \x0f\xa0\xfb\xb6\xdf\xfd\xdc\x8a\xdbGe*\xa8H\x04\x85\x88\xdd\x8d\x8d\xeaV"\
3343 \x94\xa9\x88\xea^\x06\x83\xee\xec\xac\xbb\xfe\xc3\x9b\x07]=\xc8SAy\xcaS\x1e\
3344 \xe5\xd3\xee\x0f}T\xad5\xb6\xb7+\x8cAL9y\xe8e"O\xce8;<\xb4\x83\x83v*\xc9\n\
3345 \x9b\xd2)Ky*E\x8f7:\x87C?=\xf5\xe3\xa3\xbc\xb8\x90\x14\x11\x1d\x82I\r\xbe\
3346 \x94H8\x11\xa9`\x89,\xa5\x14\x00s++\x9f\xf7\xf6@bi\xa9\xfd\xa6`\xf3\x1eF\xbc\
3347 \x10\x160N=\x87\xbf-"H\x92\x04\x19d+x\x05?y]\n-\x0c\xc2^\x00\x00\x00\x00IEND\
3348 \xaeB`\x82'
3349
3350 def getPABitmap():
3351     return BitmapFromImage(getPAImage())
3352
3353 def getPAImage():
3354     stream = cStringIO.StringIO(getPAData())
3355     return ImageFromStream(stream)
3356
3357 index.append('PA')
3358 catalog['PA'] = ImageClass()
3359 catalog['PA'].getData = getPAData
3360 catalog['PA'].getImage = getPAImage
3361 catalog['PA'].getBitmap = getPABitmap
3362
3363
3364 #----------------------------------------------------------------------
3365 def getPEData():
3366     return \
3367 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3368 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3369 \x00\x00\xcfIDAT(\x91\x85\x91\xcdm\x821\x10D\x9f\xe1\xeb\x01q\xe0\x00}\xd0\t\
3370 \x9d\xd0\x15\x8dP\x00\xd7D4\x90\\\xbc\xb3;9\xf8\x0b\x7fB\xc9h\x0f\x96<O\x1e\
3371 \xef4sW\x01\xd7+U@\xdd\xb4\xdd\x16\xdcf\x028\x1e\x01W\xb5*V+\x1bp\xb3\x97\
3372 \xb0\xb0}88\xc2\x92#\xbeN\xa7\t\x00\xfb\xe3\x93L2=\xec\x8f\xba\\\xdc\xbb#\
3373 \xdaf3\xbf\xe0\xf2\xec\x8exu\xdb\xee}\x00D\x14L\x05-\x13\xc9\x12\xa1W\xf73\
3374 \xc0\xfc\x07\xe5H\xf9\x0f \xfdFJYr\xf4\xbf\x81v\x8f\x14\xe1\xde\x91\xdc\xfb{\
3375  bd\xd6\x00\x96\xd2\x88\xe8\x88\xf7\x80\x02%\x99\x0c`\x11b\xbdv\x04\xca\xd1`\
3376 k\xed^\xe7n7vHfA\xfb~h\xb1\x80\xf3y.X\x9a\x0f\xfb\xfd|\x05\xc0\x0f\x02=a\x84\
3377 \xb72\xeb\xb6\x00\x00\x00\x00IEND\xaeB`\x82'
3378
3379 def getPEBitmap():
3380     return BitmapFromImage(getPEImage())
3381
3382 def getPEImage():
3383     stream = cStringIO.StringIO(getPEData())
3384     return ImageFromStream(stream)
3385
3386 index.append('PE')
3387 catalog['PE'] = ImageClass()
3388 catalog['PE'].getData = getPEData
3389 catalog['PE'].getImage = getPEImage
3390 catalog['PE'].getBitmap = getPEBitmap
3391
3392
3393 #----------------------------------------------------------------------
3394 def getPHData():
3395     return \
3396 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3397 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3398 \x00\x01qIDAT(\x91e\x91\xb1k\x93\x01\x14\xc4/_?\xb5\xf8Y\xc9P35K\x15\x84\xb6\
3399 \xa0\x88\xe0\xd8\x7f\xa0\x8bvu\xed\xea\xd4\xbdC\xff\x01\xa1BD\x05\x07\x11+\
3400 \xa4 \x11\xda\xd9\xa9\x14\xa1:9T\xb0\x8a..\x89\xa0&\xe6\xbd{\xef\x1c\xbe*A\
3401 \x8f\xe3\xb8\xe1w\xd35vv:\xab\xabC\xe0\x07\x00 \x81\x04\x08\x10H\xc0\x00\x02\
3402 6Y\x1a\xd2\x8d~\xffQ\xafw\xe6\xe8h\x90\xa9\x08\x91\x19\x91\xa4\xc8\xa4\xa73\
3403 \xe8\xe9L\xf7\xe8\xf5\xb6\x1a\xa3\xd1\xd7\xe9\xe9V\x84vw\xbft\xbb\xef\x87C\
3404 \x8b\x80\xbb\xdc\xd3=\xdc\xc2<\xcc\xd2=\xda\xedjo\xefn\x01\x9c\x97\x86E\xf1a\
3405 e\xe5\xd4\xfa\xfaB\xbb=c&\xf7p\xa3\x9d\xd0aF3\xba\'`Ef\x02\x9f\x81\x8e\xd4Y\
3406 \\\x98\xda\xd8\xb8\xbe\xb44c\x16cK\xb3\x18\x8f\xebA\x98E=(\x81\xef\xc0\'\xe9\
3407 \xa3t\x168\xae\xaa\xab\x9b\x9b\xdb\xdd\xad\xc5\xc3\xe7\x03Z\xd0\xe9\x164\xd2\
3408 \xd9\xe2\x85Wx]\x02\x954\']\x12Z\xd0E\x8d\xc6z2\x7fk\xfb\xf1M3\xb9k"\x0b\x9f\
3409 \xbf\x03\x94\x99\x90\xe6\xa4\xdb@S\xef\x8eu\xef\xa1\xde\x1c\xca\xfd\x1f\x1a\
3410 \xa4H\x02e\xe6O`V\xba\x8c\x17/\xf5\xe0\xbe\xbe\r&\xb9\x93B\x07\x03\x11\x00\
3411 \xca\xcck\xea?\xc3\xd3\xb7:\xd8G\xb3\x89s\x15\xdc\x1b\xee Q\'\x89\x88\xda\t\
3412 \x94\xa7\xbbW~\xad-\xe7\x9f\x93\xff\xbe\xfd\xbfk\xfd\x067!U\xfbOY\xcaK\x00\
3413 \x00\x00\x00IEND\xaeB`\x82'
3414
3415 def getPHBitmap():
3416     return BitmapFromImage(getPHImage())
3417
3418 def getPHImage():
3419     stream = cStringIO.StringIO(getPHData())
3420     return ImageFromStream(stream)
3421
3422 index.append('PH')
3423 catalog['PH'] = ImageClass()
3424 catalog['PH'].getData = getPHData
3425 catalog['PH'].getImage = getPHImage
3426 catalog['PH'].getBitmap = getPHBitmap
3427
3428
3429 #----------------------------------------------------------------------
3430 def getPKData():
3431     return \
3432 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3433 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3434 \x00\x01\x8dIDAT(\x91eQ\xcdJ[a\x14\x9c\x9b{\xbd\x90&\x11i\x17%M\x04\x0b\x9a"\
3435 \xdd\xd8\xad\x15\xea\x03\xf8\x08\xe2\x0b\xb8\xad\xdbf\xe9\xdaM\xe9[(Y)\xb8sU\
3436 \xe8\xcf\xd6E\xc5\xd4\xc4J\xa5Tb\x92&\xdf\x9c\x9f\xaf\x8b\xabT\xe8Y\x1c\xceb\
3437 f83\x93\x0c\xc2\x00\x00\x80\x11G\x8d\xf7\r\x8c\x00\x07\x14P\xc0\x01\x02\n\
3438 \xf0\xfe\xc8\x90\x01\x98\xcdg\x01\xe4i\xde~\xd3\x1e\xcbXa\xe6\xaa\xa6\nU\x13\
3439 qU\x131\x15\x97\xce\x87NV\xc8\xc7\x18\xdd\xbd7\xee\xdd\x86[s\x8b\x88\x8dJ\
3440 \xf3\xfb\xcd\xd9\xc4&\x14\xd2).\xf3\xd5y\x10\xa5\x02]lu57*\xb7_n\xaf=}=\t\
3441 \x93,\xc9vVv\xea\xe5:\x95\xe2\x02E\t\xf7\x13\x11\xd5\x95\xca\xd5\xfajk\xaeu\
3442 \xd8;\n\x1e\x9a\x95\xe6\xf2\xe3\xe5\xcd\x17\x9bT\x8a\t\x88\xcc\xdd\x0b\xf9\
3443 \x18\xa3\x98\x88Hm\xa6VN\xcb?F\x974~\xbe\xfe\xb2\xfbi\xf7bx\xc1H\x8d\n\xa2\
3444 \xe4~\x87.\x08\x8c\xbc\xfe\xf33O\xf3\xad\xd6\x16\x03\x19\xc2I\xff\xa4;\xec\
3445 \x8a\x8b\x98@\x91\xc1\xfd\x01\x81t\x1ev\x8fV\x9e\xbc\xdax\xbe1\x08\x83!\x87\
3446 \x0b\xb5\x85\x83o\x07\xc7\xfdcs\x85"s\xfc{\x89.42\xb2\xfd\xf1]\x7f\xd8_\x7f\
3447 \xb6^\xcd\xab{_\xf7N\x7f\x9fNm\xaafw\x1e\x8a\x94\x92$\xa9W\xea\x95\xb4"Q\xc4\
3448 \xa4s\xd6\xd9?\xdf7\xb7 !\x9dI\x17\xe7\x16-\x1a\x14\xc9\xd5\xcd\x95\xbb\xbb\
3449 \xfbT\xa7Ko\x97\xf0\xeb\xbf\x82\x1f\x16\xff\x08\x7f\x01\x87\xca@\x8cM\x0b%\
3450 \xe5\x00\x00\x00\x00IEND\xaeB`\x82'
3451
3452 def getPKBitmap():
3453     return BitmapFromImage(getPKImage())
3454
3455 def getPKImage():
3456     stream = cStringIO.StringIO(getPKData())
3457     return ImageFromStream(stream)
3458
3459 index.append('PK')
3460 catalog['PK'] = ImageClass()
3461 catalog['PK'].getData = getPKData
3462 catalog['PK'].getImage = getPKImage
3463 catalog['PK'].getBitmap = getPKBitmap
3464
3465
3466 #----------------------------------------------------------------------
3467 def getPLData():
3468     return \
3469 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3470 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3471 \x00\x00\xbaIDAT(\x91\x8d\x8d1nBA\x0cD\x9fakz\xc4\x9d\xb9\x037\x83\xe6\xf7\
3472 \xa0\xa4\xd9\xf1zRl\xf2\xc5\x0fD\xcahl\xd9\xf2\x1b9|\xbf\xf3\xa3Z\xab\xaa\
3473 \xa0\xde\xa9\x01\x1c\x0e\x80\xed\x00\xc0\x06\x1c\xf6\x1ev\xde\xe8cY\x1a\xdf\
3474 \x90\x9f\x07\xbfSDTf\xfb'=OU\xd5\nb\xa5\x8d\xff\xe4\rP\x15\x03\xe2|\xf6\xb28\
3475 \x93L\xaf\x96\xact\xca\x92%g\xc6\xe9t\xbf\\\x1a\xe0\xdb\xcd\xd7\xab\xd5\xd1\
3476 \xe4\xba\xbb\xdc\xbb\xb5\xe9\xf1x\x14\xb4\x82\x90\xdc;\x99\x1bhK\xcf\xe79\
3477 \x03\xfbLK\xac\xd0k,E\x0e\xc6`\x06vJ\x8eGK\xe4 \x85\x14\x12\x99\xcc\x9e\xc9\
3478 \x18\xd3\x05\xf1\t\xf5d\xb6\xeb\xaf\x13\xf0\x05\xc2\x7f]y\xc1\x7f\x96\x92\
3479 \x00\x00\x00\x00IEND\xaeB`\x82"
3480
3481 def getPLBitmap():
3482     return BitmapFromImage(getPLImage())
3483
3484 def getPLImage():
3485     stream = cStringIO.StringIO(getPLData())
3486     return ImageFromStream(stream)
3487
3488 index.append('PL')
3489 catalog['PL'] = ImageClass()
3490 catalog['PL'].getData = getPLData
3491 catalog['PL'].getImage = getPLImage
3492 catalog['PL'].getBitmap = getPLBitmap
3493
3494
3495 #----------------------------------------------------------------------
3496 def getPRData():
3497     return \
3498 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3499 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3500 \x00\x01\x8bIDAT(\x91m\x91\xcfK\x94a\x14\x85\xcf\xfb\xbd\xaf\xe3\x8f\x99\xc1\
3501 \x8d\x89\x90ZH\x04\xa5`\x88\xe6\xbe\xfe\x81\xfe\x80 \x82V\x82P\xdb\x86\x16\
3502 \xad\x15\xdc\xb5m\xd1\xc66\xb3\x125\n\\L\x8a\x8b\x90\xa1\x854.\n\x86\x9a\x85\
3503 \x88\x85\xe07\xf3}\xf7\xbe\xf7\xb8\x185\x17\x1e\x9e\xc5\xdd\\x\x0e\xc7\x01\
3504 \x8d\x0fx0\x85v\x07\xc8\x01\xbb\x82\x02\n\xe0\xe2P \x01\x02p\xb7Y9\x1aBm*\
3505 \xd9\xedq\x99d\x91jT\xb1\x18\xa9\xda\xc5DL\x84\xaa\xbb\xd5\xaa\x03\xf8\xa6\
3506 \x82\xe6o\xde.\x1d\xbe\xaa\x0c\x94\x87zi$@\x12\xbcH\x92\x90\x84\xd9\xdf\x83\
3507 \x83\x04\x80\x1a\xcb\xfdh\x1c\x0f/\xbe.6\xff\x84\x98\x04x\x0f\xefy\t@\x00\
3508 \xde[\x08\x0e\x88++\xee\xf1#l}\xe1^\x1dG\xc7|6V\x9d8\xa9\x95\xe5\x90\x92\x9d\
3509 \xcb\x88\x98Hattgu5\x00x8\x8b{\xf7Y\x1c`\xed+L\xf8\xee\xc7\x93\xa7\xb11\x93}\
3510 \xf3y\xbb#bynyn"}d\x0b\x08\x00>m0F\xae\xaf1=E;\xe7\x8b[\x1fgK\xff\xbcNS\xa5W\
3511 \xc4\xba\xbdc\xec\x19\x19\x19\xdf\xdev\x80\xbc\\p\x8d_TE_?\x97\x9686\xce\xe4\
3512 \x7f\xdf\xf3\x00p\xce\xb5\xf6\xf7\x03`\x1d\xf5"\xbcSn\xbd].\r\xde,\x92\xa4\
3513 \xd1TI\xd2\x8c@\xf7\xdd9\x874u@{\xf1y6\xaf\x1bs\xf8\\\xc0i\x96\xaau5.eT\xa9\
3514 \xd1,"\xc6\xcdz=\x00?\x87\xdfO\xde\x00\xbe\x03\xe9\x95\x81\xf3\xeb\xf6.\x00g\
3515 \x9eG,\x0f\xd3,\xbc\x95\x00\x00\x00\x00IEND\xaeB`\x82'
3516
3517 def getPRBitmap():
3518     return BitmapFromImage(getPRImage())
3519
3520 def getPRImage():
3521     stream = cStringIO.StringIO(getPRData())
3522     return ImageFromStream(stream)
3523
3524 index.append('PR')
3525 catalog['PR'] = ImageClass()
3526 catalog['PR'].getData = getPRData
3527 catalog['PR'].getImage = getPRImage
3528 catalog['PR'].getBitmap = getPRBitmap
3529
3530
3531 #----------------------------------------------------------------------
3532 def getPTData():
3533     return \
3534 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3535 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3536 \x00\x01^IDAT(\x91m\x911k\x93a\x14\x85\xcf\xf7\xe6mR+\xa5B:\xd8!\x82\x83"\
3537 \xe2\xa4\xfe\x03\x9d\xdc:\xbat\xeb \x9d\x9c3v)\x88\xbf@\xdc\x04g\x0b\n\xfe\
3538 \x01A\xf4\x0f\xe8\xa0K\x9d\xa2i\x89\x89\xe9w\xcf\xb9\xf7:$\xa1K\x0f\x0f\x973\
3539 \xdc\x87;\xdc\x06O\x81)\x96\t\xa0\xc2\xdf-\xeb\xa5TL0\xdc\x1f\x02\x88\x88\
3540 \xc8\xf0\xc6q\xd3\xe1j\xa4\x8eT\xc8\x94r5\xa7\xc7\xc7\x15\x05@\x9e\x9c\xfe\
3541 \xda\xe8\xf8\xfd\xbe\xdf\xebS\xbb\xae\x11\xbbo\x99\xa7Lc\xd2\xd2,\xc9f0\x08\
3542 \xa0\x02\x88H\x0f\x7f\xfe\xd0\xb7Zu\xdf8\xe7\xcc\xc7\x9c\xeeq\xe3\x85%-\x8d\
3543 \x0b\x01d\x00\x05\x01O\x97t6\xe3\xfa{u\x0f\x0e\'\xcf\x8e\xec\xcbv\xd3\xa3`\
3544 \xd9Z\xda\n\x12@\x81A\xeetVp>\xb3\xb6\\9\xbb~\xbb-kQZ\xaeY\x92\x17\x82\x14@\
3545 \x85\xc1C\n}\x1d\xd9\xadG~\xe7\xd5p\xfb\xea\x8d\xf9\xee7K\xeb\x8f-\xdb\x95C6\
3546 d\x00\x15\x02\x9d\xe6\xf6\xf1\x87\xfaw9yrr\xed\xcf\xcf\xeewv>Y\x99]lCJI\x8b\
3547 \x0b\n\xd1\xf9[|\xf9\x99\xbdM\xfb\xf0\xda\xd4c\x19[\x92KA\x84\x1c\xee\x00*\
3548 \xfe\x81\xd2\xce\xd6\x0eE\xb9+\x89\x01+\x99\x9b\x02\t\t\x12\xdc\x17\x04\xd0\
3549 \xe0\x010\x06\xce\x01\x03\xce\x81\x82\xd1\xdf\xcb\x7f\xbc\xc8\x7f\x8e\xd7Fv\
3550 \x05\x02MO\x00\x00\x00\x00IEND\xaeB`\x82'
3551
3552 def getPTBitmap():
3553     return BitmapFromImage(getPTImage())
3554
3555 def getPTImage():
3556     stream = cStringIO.StringIO(getPTData())
3557     return ImageFromStream(stream)
3558
3559 index.append('PT')
3560 catalog['PT'] = ImageClass()
3561 catalog['PT'].getData = getPTData
3562 catalog['PT'].getImage = getPTImage
3563 catalog['PT'].getBitmap = getPTBitmap
3564
3565
3566 #----------------------------------------------------------------------
3567 def getPYData():
3568     return \
3569 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3570 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3571 \x00\x01\x1fIDAT(\x91mR;J\x04A\x14\xac\x9e\x19\x075\x11\xc1@\x84\xdd\x0bx\
3572 \x0cS\x03\xf18n``b\xe8-D\x10\x83\xc5\x1b\x18\x8a\x81W\xf0\x83,\xac\xff]\xd4\
3573 \xe9zU\x06\xe3\xfe\xc0\xe2QT?\xea\x15\xdd\xf4K\xc6\x0cZ\xd4\xffV2\x80^\x0f\
3574 \x80%H\x880\x03A\x93 \x9d\xb3\xe7x\xd4\xefW\x00\x00\xfb\xe1\x11\x11\x88p\xce\
3575 -\xffU\x93\x9d\x1b7\x8dsN\x9d\x8e\x80\n\xe3\xb1\xeb\x1a\x12\x00\xdb\xf0\x14\
3576 \x98\x1d$\xdb(\n\r\x87\xd5\x9b\xea\xb5\xb2DY\xfeY`\xdd\xdd\xfd\\^(\xe7zw\x1f\
3577 \xdd\xee, \xa5aS\x17\xedK\xa7\xa1\xb6=\xfa8\xdd~9\x1c\xed\xf8\xf3\xd5\xf3\
3578 \x00H\x15\x92\x16\xdc6V\x96\xf7\xae|\xf0}\x86\xe5\x95\x05\xbf\r)=\xbf\x7f\
3579 \xad\xd6K!\xb5\x13\x9a\\\x1fVx\xd2\x90eTe\xf1\xf04HX\xbf=:\xde\xba\x1fdR\x99\
3580  \x95iRy&L)\xe8\xeef}~r]\xa1\x11\xc3\x1b\xebE\xb0`\x98Q\x90\x8aH\x8c\x92\x14\
3581 \xc3\x11\xa2\xa00-\x00\t\xe5\r\x82\x80\x80yn\x05\xe7\xbe\x98\xed\x06\xfc\x02\
3582 o\xefV\xf1,"\x04\xa3\x00\x00\x00\x00IEND\xaeB`\x82'
3583
3584 def getPYBitmap():
3585     return BitmapFromImage(getPYImage())
3586
3587 def getPYImage():
3588     stream = cStringIO.StringIO(getPYData())
3589     return ImageFromStream(stream)
3590
3591 index.append('PY')
3592 catalog['PY'] = ImageClass()
3593 catalog['PY'].getData = getPYData
3594 catalog['PY'].getImage = getPYImage
3595 catalog['PY'].getBitmap = getPYBitmap
3596
3597
3598 #----------------------------------------------------------------------
3599 def getQAData():
3600     return \
3601 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3602 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3603 \x00\x01$IDAT(\x91}\x90\xcf*\x85Q\x14\xc5\xd7\xbd}\x19\xdcd`\xa4\x90\x97\xf0\
3604 .\x94\x94\x8cL\x94\x81(\xa2\xc8@)L\x8d\x0c\x0c\x98x\x0f#^Af\x92\x7f\xe9\x96\
3605 \xbb\xd7\xda\xeb\x18\x9c{?FV\xbb38\xfb\xb7\xd7Y\xfbt\x06\xfd\xbe1\x94\xe1\
3606 \xd5\xa9\xc9\xfb/\n\x08\xe0{t\x12\xbf\xea\x0c\xfa\xfd\xb1^\x0f@)\xa5^]\xedng\
3607 \xd2\x99\xa9L2%\x91)Y\xdc\xba\xbem\xaa}K\xdf\x1c\xee\xbf<=\xa6$J\x8c$E\x8a!r\
3608 rz\x06@\xf7/m{a\xef@\xaaD\x88$C\x0cF0\xc2"\x80\xa6\rW\xc7\xaev\xb6\x92T\x84\
3609 \xa8\xd6[\x11"\x93\x02\xd0\xb5]\xe9:\xb0tt\\\xdb\xe2@\x11\x8c!\xcd\x08\x91\
3610 \x00\x1a\xdbe\x88\x97\xe2r\xb9\xb9A\x86\xe27\xbaH\x05M\xa6\x08\xa0\xeb\xd6\
3611 \xbe\xa0\x94\xb2rr\xa6\x081\x14\xb58z\x90\x99\x02\xd0`\x14\xa9nr\xb1\xbe\xa6\
3612 h\xa3S\xa4D\x93J\xa5\x0c\xa0\xf3\xf9\xfe\xda\x1b\x9fhw(\xa5\x9c./\xa6(\xd5\
3613 \xbf\xcf\x94\x9c\xcaLg\x9e\xdf=4\xb6?\xde\xdel\xdb\x965?;\xf7\x8c\xff\xf4\
3614 \x03k}[\xe5\x9e\xcb>\x13\x00\x00\x00\x00IEND\xaeB`\x82'
3615
3616 def getQABitmap():
3617     return BitmapFromImage(getQAImage())
3618
3619 def getQAImage():
3620     stream = cStringIO.StringIO(getQAData())
3621     return ImageFromStream(stream)
3622
3623 index.append('QA')
3624 catalog['QA'] = ImageClass()
3625 catalog['QA'].getData = getQAData
3626 catalog['QA'].getImage = getQAImage
3627 catalog['QA'].getBitmap = getQABitmap
3628
3629
3630 #----------------------------------------------------------------------
3631 def getROData():
3632     return \
3633 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3634 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3635 \x00\x01\x14IDAT(\x91]\x911J]a\x10\x85\xbf{\xf3?Iz\x9b \x16\xda\xba\x00\x17\
3636 \x92\xc2&\x0b\t\xd8eI\x0fR\x06\xec\\\x84\x9d\x08\x16\x81\x18\x82\xa8o\xe6\
3637 \xcc\x9c\x14\xf7\x06\x9f\x0e\xa7\xfd\xe6|p&\xce\xae\xf9+\x00f\x18\x0fW\xe7\
3638 \x1f\x0f\xa0\xe9\xa6\x9b\xf1B\x9f\xd1\xbcf\xf0[\x97\xdfO\x80\xee\xa9=\x7f:\
3639 \xfa\xb6\xd9\xec@\xb6@~L\x7f\x953-9\xf3q\xbb\x1d\x0c0w\xbf\xb2\xda\xd5s\xf7-\
3640 <\xdb\xb9F\xe9\x9bp\x843\xa7\xe3\xe3\x86\x01\xb4\xa9\xb6\xca*\xdb\xb2\xc3\
3641 \x96\x9dv\xb8\xc3\x91\x0b@f\xc3@]mUK\xa8l\xc7\xeb{\x87\xfd\x06\x00\x06\xd1*\
3642 \xa7\xfc\x1f\xc8=&\xect\xacJH\xbd\x00U-9d\x15{@\xd8\xb9\xaf4\xadJ\xd1Y\x84Zr\
3643 \x8aU\xe3]C&\x92%\xc1`'\xa93;\xe5\xaci\x0fX\x1a\xd2\x11V\xa2\xa2\n\x18\xa0\
3644 \x94?\x1fnRV}\x98\xe7#x\x9a\xa6\x04A2\xc4\xa9\xa8Z\xd20\xc1\x0f\x08\xd0\xb2\
3645 \xe3\xfd\xcf/c\xd0\xa2\xa1E\xff\xa1/\xd6\x8d\x97\xfb\x07'\xado\x9d\xaf7f\x92\
3646 \x00\x00\x00\x00IEND\xaeB`\x82"
3647
3648 def getROBitmap():
3649     return BitmapFromImage(getROImage())
3650
3651 def getROImage():
3652     stream = cStringIO.StringIO(getROData())
3653     return ImageFromStream(stream)
3654
3655 index.append('RO')
3656 catalog['RO'] = ImageClass()
3657 catalog['RO'].getData = getROData
3658 catalog['RO'].getImage = getROImage
3659 catalog['RO'].getBitmap = getROBitmap
3660
3661
3662 #----------------------------------------------------------------------
3663 def getRSData():
3664     return \
3665 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x11\x00\x00\x00\x0b\x08\x06\
3666 \x00\x00\x00\x99 f\x07\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
3667 \x01'IDAT(\x91\x9d\x91\xbdJ\xc3`\x14\x86\xdf$_C\x9a\x984E\xab\xc1A\rEQ\xc9\
3668 \xe2\xe0\xe05\x88\xa3\x93\x8b\x827\xe1e\x88\x83\x9b\xae^\x85\x93\xf0!B\xa7\
3669 \x06\x1c,U,\xda\x14\x0bI%6i\x93|.\x1a4\xa5M\xf5\x19\xdf\xc3y8?\xdc\xc9\xea:3\
3670 e\x05\xff\xa5\xf9\xe1\x83\x98\xb2\x02K+\xfd*\x84$\xc1\x90D\x98\t\xc4\xa9D$\
3671 \x1b<\xe8@\xb8\xd2\x03_\xe4 4$\xacu\x92|\xc9U\xa4\xd6g\x87\xfa\xfbw\xb0\xbbT\
3672 5\xe7\xcb\xdd28\xc05\xf4\xdey\xa7\xd5\x0c\x86Q<N\xd0\x8d\x12\x95\\\x1b;\x16\
3673 \xe6\xaaix`\xba\xf0^=0\xf0\xd0\xcc\x85\xca]\x7f\xa3r\xefs\xe3\xc7xk\x80\xcff\
3674 \xbe\xae\x83\x0bE(q\x11\x03c1w\x15\x00\xa3\x12\xdei\xa3\x00@\x94$\xc4/-\x04\
3675 \xc9\x84)\xbe \xfb\x9bb\xddX\x96\xd2\x9b\xf0\xcf\xb5m_\x90I\x9f\tP\x1ei\xb2g\
3676 \x1d\xdfN\x12\xb4\x9fD\x15\x94R\xf6\x93\x81\xeb\xb1\xda\xc5%\xbb9=c\x81\xe3\
3677 \xb0<(\xa5l\xe4\xc5\x85\x92\x86\xad\xa3\xc3\xa9n\x91\xaec\xdb\xf6\x9f\x1a\
3678 \xb2\xd8\xb6\x8dO>1\x8eT\x1c4\xb0\xeb\x00\x00\x00\x00IEND\xaeB`\x82"
3679
3680 def getRSBitmap():
3681     return BitmapFromImage(getRSImage())
3682
3683 def getRSImage():
3684     stream = cStringIO.StringIO(getRSData())
3685     return ImageFromStream(stream)
3686
3687 index.append('RS')
3688 catalog['RS'] = ImageClass()
3689 catalog['RS'].getData = getRSData
3690 catalog['RS'].getImage = getRSImage
3691 catalog['RS'].getBitmap = getRSBitmap
3692
3693
3694 #----------------------------------------------------------------------
3695 def getRUData():
3696     return \
3697 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3698 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3699 \x00\x00\xf2IDAT(\x91m\x8f=N\xc2Q\x10\xc4\x7f\x0f\xfe\x15v4\x86X\xd0\xd8Xx\r\
3700 \x13nB\xcb=<\x85W\xa0\xe0.\x16\x16\x14\x86\x8e\x98HL\xde\xcc\xdb\xb5xD>d\xb2\
3701 \xd9\x9d\xdd\xd9\x8fl9\x1c\x92\x13"\xa2\x87\xce\xe2\n\x0e\x06`2\x01\xc8L(@f\
3702 \xcf\n\x8c3Gy\x86\xdd\xee{\xe8\x9b3\xf3\x9c\xe4-\x94R"\xa2,\x16\xb9\\\xe6~O\
3703 \x04\xadekDdki_x;\xa7\xd3\xb2Z}\r\x9bM<?\x97\xed\x16;-\xe4\x94R\xcaZ\xaf\xfd\
3704 |\x0e0\x006R\xfe\rt\xb9\xf7U\xa5\xea\xb1b\x17\x88\x01\xe8G\xab\xd2\xe2\xd4\
3705 \xfa\xef\x82\x94\x10\xc3\x9a\xf1\x93^\x7f\xeag\xd8Y\x1drT\x85\x1c\xd2\x91T7)\
3706 \xdc\xee\xfc\xb0\xe6mx\x81\xb1\xdfC\x1f\xb7\x97wb\xe1V\xda\xe3=\x0c\x01#\x99\
3707 \xd9,%\xdc\xb0\x90\x8a\xd4?\xc3\xc6\xa6\xb5n\x01\xe5\x00qf\\\xa6W\x12\xf0\
3708 \x0b?\x89e\x1eo\xd1Q\x86\x00\x00\x00\x00IEND\xaeB`\x82'
3709
3710 def getRUBitmap():
3711     return BitmapFromImage(getRUImage())
3712
3713 def getRUImage():
3714     stream = cStringIO.StringIO(getRUData())
3715     return ImageFromStream(stream)
3716
3717 index.append('RU')
3718 catalog['RU'] = ImageClass()
3719 catalog['RU'].getData = getRUData
3720 catalog['RU'].getImage = getRUImage
3721 catalog['RU'].getBitmap = getRUBitmap
3722
3723
3724 #----------------------------------------------------------------------
3725 def getRWData():
3726     return \
3727 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3728 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3729 \x00\x01EIDAT(\x91m\x8c1\x8a\x94Q\x10\x84\xeb\xbd\xff\xcd\x82\xb2*\xc8l\xb0\
3730 \x91\xe0e\x043\x83=\x81\x08\x06bd"\x82\x81\xe0\x9a\x19\xe8\x01\xcc\xf4\x10"x\
3731 \r1\x11A\x1cW7\x19u\x1c\xbb\xab\xab\x0c~\x06v\xc1\xa6)\xaa\xa0\xbej\x97\x9e:\
3732 \x84\xf9(\x15\x01\x01\x04(H\x08\x81B\xec\x8c0Bx~\x03\x00l\x97\x9b\x0c\t%\x97\
3733 [iJu\x8bG\xcb\x17\xcd\xf1\xfa\xeb\xbd\xe3\x97\x1a\xf3\xf6\xc9o\x97!\x81r\x15\
3734 h\xb3Ly\x9b\xbes\xf8d?>tm\x8e\x96q\x8c\xfb]\x80\xe5\x12J\xa0\xccB\xdaYf9\xcb\
3735 \x94\xdf\xac\xee\xfea\xff\x16\x07oOo!42D\xb7(\x94<3%Wy\xbbc\xbe\xc4\xc1\xa3\
3736 \x8f\xaf(/\xf7\'\xac\xd7\xed\xe7_,\xa6\x87\xd6g\x83v\xda\xb4\xc3N8\xed\x94c\
3737 \x8e6[\xbf\xb6\xfa\xfen\\\x1c\x006\xee\xbf\x8c\x80g&\xfe\xab\xbd_\xbd\xbc\
3738 \x87!\xa1\xb5\xb4\x03\xe0\xf9\xd2\xb96@\x9b$\xc6\xe21\x1e\xdc\xe4\xa7u\xa62+\
3739 \xb3"\x14\xb3\xc9J:\xb3\x82\x95\xa9\xba~\xa5\xde?\xc3\xc0\tN\xb7\xbc0\x0e\
3740 \x87r\xd1\x8a=\xf7*\xb3\';sJ\x169\xb1TU\xf5cSX\xa1\xe16\xb0\x05\xe2\xcc\xf3\
3741 \x8c\x06\xa0]\x140\xf0\x0f\xf8\xb9h\xc1\xd7\xfaS\xe0\x00\x00\x00\x00IEND\xae\
3742 B`\x82'
3743
3744 def getRWBitmap():
3745     return BitmapFromImage(getRWImage())
3746
3747 def getRWImage():
3748     stream = cStringIO.StringIO(getRWData())
3749     return ImageFromStream(stream)
3750
3751 index.append('RW')
3752 catalog['RW'] = ImageClass()
3753 catalog['RW'].getData = getRWData
3754 catalog['RW'].getImage = getRWImage
3755 catalog['RW'].getBitmap = getRWBitmap
3756
3757
3758 #----------------------------------------------------------------------
3759 def getSAData():
3760     return \
3761 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3762 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3763 \x00\x01sIDAT(\x91}\x91\xbdjTq\x14\xc4\xe7~d\xb3\x9b\xc0"q\x8b\x801FBj\xadU\
3764 \x14l}\x8bT~4y\x04}\x86\xd4\x82\x9d\xd1\xbc@*\x9b\x10,T\x04\x85[\x08\x1b\xbb\
3765 U\xd8\x15\xd6\xe4&{\xef93\xe7oa\xa2\xb1q\x8aa\x9a\x1f\x033\x19\x1e\xe0\xaf\
3766 \x02 @\xc0\xce\xdd\x80\xe6BhP\x02x\xf6\xf0i\x02\x12\x82\xa2B\x11\xc1 EJ\x0cw\
3767 \xbaB\n\xb9\xfc\xf5\xa3\xdd\x12@\x02F?G\x11\x91#\x07\xd2i{j\xb4\xb9\xb2\xe3\
3768 \xb4\x995\t\xe9\xa4\xad\xeb\xe6xe\xe9*\x80\x12\x81\x94R\xcb\xe6\xd6\xf5;\xeb\
3769 \x977\x8e\x9b\xa3w_\xdf\xdf\\\xbd\xd1\xc9;E\x96\x1f\x0c\x0f\xeen\xdc\xfb<\
3770 \xfa\xf4\xe2\xeds\xa7\x9f\x01\x0cRr\xfa\xd1l\xda\x9d\xeb\xad\\\xba\xd2+z\x87\
3771 \xe3\xc3\x96\xedt6\xfdQO\n\x14&\xba\x1c@\x0e\x83B\x94\x0f\x16\x07k\x83\xb5q=\
3772 \xa9\xad\xae\xbeW\xdd\xce|\xf5\xad\xea\x16\x0b\xc3\xf1p\xaf\xda\x93H\xf1\xac\
3773 A\xc1\x94\xb0\xfb\xf1U\x962\x06Mfn$\x1b\xb6y\x96ON&\xa4\xa7H\xe7\x80\x81\xa2\
3774 \xcb\xcd\xdb\xcd\xdb\x9b\x0b\xe5bJ\xe9\xcfV\xfd\xf9\xbe\xcb\x9f\xec<n\xd52.\
3775 \x02t\x06\xb7\xdfl3\x14\n\x939\xddd[\xf7\xb7\xf6\xbf\xec\xbb\xfc\xf7\xd0\x00\
3776 J4\xf0\xe0r\x7f\x99\xe1NR\xeer\x8a\x1eNq\xe7\xc3KQ\xabK\xd7\x18\x8c\x08\x00\
3777 \x19\xd6\xff9\x12-\xfe\xaf_0z7\x17\\\xc4@\x1d\x00\x00\x00\x00IEND\xaeB`\x82'\
3778
3779
3780 def getSABitmap():
3781     return BitmapFromImage(getSAImage())
3782
3783 def getSAImage():
3784     stream = cStringIO.StringIO(getSAData())
3785     return ImageFromStream(stream)
3786
3787 index.append('SA')
3788 catalog['SA'] = ImageClass()
3789 catalog['SA'].getData = getSAData
3790 catalog['SA'].getImage = getSAImage
3791 catalog['SA'].getBitmap = getSABitmap
3792
3793
3794 #----------------------------------------------------------------------
3795 def getSBData():
3796     return \
3797 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3798 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3799 \x00\x01\xcfIDAT(\x91\x85\x8dAH\x93a\x1c\xc6\x9f\xb5\xef\xfbH%\xdc\xc2\x82\t\
3800 -\x0bV\x07CI\x0c\x84\xc5N\x16\x11Q\x87\xca\x08\x82X]\xbc\xe4\xa9\x08\xf1R\
3801 \xb0h\x97\x0eQ\x04\x1dZ4\x08\xa6x\xf1\xd2h\xe1\xa0b\x0ea\x8e\xc0F\xd1\xa1I\
3802 \x08}\xd1*\xb7\x9c\xce\xf7\xf9\xbf\xef\xd7au\xeewxN\xcf\xf3{|~\xffR"\xd1;9\
3803 \xf9qj\xea@2\xe9j\xdd\x00\x0c\x00@\x00\xf3/;\x81\xd5\xfb\x17\xe2C\xa3\xb0R\
3804 \xa9\xf0\xd8\xd8N\xdb\xc6\xc4\xc4\xee\x81\x81\xed\xa5R\x93\x84\xd6F\xc4\x131\
3805 B\x1f\xc5:\x19]\x88\r\xbd\xf3:\xae&\x1e?\xf1\x01oS\xa9\x83\xc3\xc3]\xe9\xf4O\
3806 \xd7U\xad\x96\xd1\xda#\r\xe9\x91\xb6\x1f\x9b7/??\xd4_\\Y\xb7o\x97\xec\xec\
3807 \xf5\xac\x05X\xf5\xba\t\x06\xfd\xa2Mw\xf7\xb6fS\x94\xf2D|T\xce\xe9\xd8\x9bs\
3808 \xc7\xe6\xd1Y\xcbVqw\xf1KxW\x18\x80\x15\x8d\x06\xc6\xc7{\xe2W\xaaOS}\xb3\xb3\
3809 k\x99L\x8dt`Z7.M\x1f\x1e,|h\xc8\xb5\x17\xee\x96(z\xa4!\x00\xabP\xa8\xe5\xf3!\
3810 *\xcc\xcc\xfc\x9a\x9bk\x90\x1d\'F\x16\xce\x1f\x7f\xd5t\xaa\xb9U\x7fr\xd1\xa5\
3811 Q\xca(\nE\x04\x80\x05\xa8\\nM\xc4\xcbL\xff\x1e\x8c|>u\xb4\x18\xd9\xb7T\xdd\
3812 \xd8\xbaW\xd8\xa8\xd4\xd6\x95\xa7\xa8\xa9D\xd1\x90\x9a\xed\x81!\xa1\x94\x13?\
3813 \xf3\xb2\xbfo\xd9\x04\xca\xaf\xbf\xed\xb8Sti\xd8\x16\xb7\xdb"\xa2\xf5\xdf\
3814 \x07kt\xa4\x12\x8c-G\xf6\x16\xbfC\x9e\xbdw\xf2+_\xe9Q\xe9\xb6\x9b\x14%\x86\
3815 \xa2\xb5\x18\r\xc0\xbax\xe4V(p\xb6w\x7f\xe5S=\xf4\xa8\xfcC<{OO\x175E\x0b\x85\
3816 bD\x8c\xe86F\x03\xf0\x15\x1f\xc0u\xf0\xb0\x8c\xf94\xb0\x89\xff\xf2\x07 \xdf+\
3817 \xe0\x8e\xc56 \x00\x00\x00\x00IEND\xaeB`\x82'
3818
3819 def getSBBitmap():
3820     return BitmapFromImage(getSBImage())
3821
3822 def getSBImage():
3823     stream = cStringIO.StringIO(getSBData())
3824     return ImageFromStream(stream)
3825
3826 index.append('SB')
3827 catalog['SB'] = ImageClass()
3828 catalog['SB'].getData = getSBData
3829 catalog['SB'].getImage = getSBImage
3830 catalog['SB'].getBitmap = getSBBitmap
3831
3832
3833 #----------------------------------------------------------------------
3834 def getSDData():
3835     return \
3836 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3837 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3838 \x00\x019IDAT(\x91\x95\x8f\xb1JBq\x14\x87\x7f\xde{\tS\xf4JK8\xb8\xf9\x00-\
3839 \x8dAkm>A/P[CDS\x05A\r\xb5\xf6\x04-MBkPo\xe0\x138\xe8\x90\xdd"5E\xfc\x9f\xdf\
3840 9\xa7A3\x83\x96>>\xbe\xe9\x07\x87\x83\xea\x1e\x1csuI\x01\xa6\xc0\x04\x18\x03\
3841 \x9f\xc0\x00\xf8\x00\xde\x81\x1c\xaeq\xb3q\xb9\xff8\x88h0\x83\xaaS\xa1t\x12\
3842 \xa4\x8b\xf8RG\xcdf\x02"\xab\xf4O6\'\xe7\xf7Y$\xea"Pu\x91\xb9A\\\x82\x87\xe0\
3843 "\xb9Z\xcd\x80\x04\x84\x05\xefV\xb2\xc3Fz\xb5}\x16y\xce\xdd\xfc\x07[\x04ql\
3844 \xedv\x04@]\x19\xd8-\xf5\x0e\x9e\x8e;+c/\x97\x97L\xbd\x9cz\x9az\x9az\xa9\xf4\
3845 \x92\xcfG h**"\xd2I:\'\x0fG\xfa\xeb\xc2\x12\x80\x99E \xd4Hc\xb0\xb0\xae\xeb\
3846 \xa7;\xa79\xc7\xdf{w3K@\xcc\xfe*\xbe\x15/v/\xa2i\xd4\x9f\xf4\xcd\xcc\xddg]\
3847 \x10\xc7\xf1p8L`\xa0\xb3\xd0+dwY\xe3\xb6\x11B\x08!\x88\xc8\xbc"\x12\x02)\xa4\
3848 \xd6\xeb\xf5V\xab\x95`\x84\xfc\xebj\xe1\xb9P]\xab\xb2\xac\xa4\xcc 9+I\xfd\
3849 \x06\x00\xb0\x85\x7f\xf1\x05oFOu\xeb\xaaZ\x1c\x00\x00\x00\x00IEND\xaeB`\x82'\
3850
3851
3852 def getSDBitmap():
3853     return BitmapFromImage(getSDImage())
3854
3855 def getSDImage():
3856     stream = cStringIO.StringIO(getSDData())
3857     return ImageFromStream(stream)
3858
3859 index.append('SD')
3860 catalog['SD'] = ImageClass()
3861 catalog['SD'].getData = getSDData
3862 catalog['SD'].getImage = getSDImage
3863 catalog['SD'].getBitmap = getSDBitmap
3864
3865
3866 #----------------------------------------------------------------------
3867 def getSEData():
3868     return \
3869 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3870 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3871 \x00\x01LIDAT(\x91M\x91?j\xd4q\x14\xc4\xe7\xbb\xfe4EDAQ\x08\x12\x04s\x00K++\
3872 \x0b\xb1\x11\xef`\x11\x10\xb62n#(\x16\x966\xdaz\x854\x82\xa5E\x0e\xe0\x19\
3873 \x02!\x9d\x8a\xa8\xb0l\xde\x9b?\x16fM\x86\xc70\xc5|^3\x03\x0f\xde`-\xbdz\r\
3874 \x03\xc6\x85\xc5\x0b\x94Q\x85"Vu\x16\xba&\x00/\xe7\x8f\x00\xd8\x19;KX\x81\
3875 \xe6{\x8f\xa9P\xa6\xdc\x12\xe5\xb6[\xfa4\xff0\x01\x00r\xfcs)\x07\'GI#:\xfc\
3876 \xf6\xa7\xe5\xa6Z*\xaa\xe4nm_\xdf\x04j\x82mC\x0eO.\xfek\xc75\x8d\xd5\x92\xb3\
3877 \x92\x9b*\xaa\xa8\xb6Z\x06j\xe8\x00\xe3\xce\x02u\x94\x10a\xdcq\'\x1dw\\q\x9d\
3878 \x86\xf4\xd8\xb8\xfd\xfb\xcb\xc1\x04\x02Q\xd2\xf1\x1aH\x9dbg\xed\x8a\x1b\xa6\
3879 \x89\tF\xc2\x98I\xc1\xe7\x81s\x9e\x8a{\xb8M\x0c\xdc}\xfel\xf1\xe4\xf0\xfb/\
3880 \xca\x9f\x1f\xbeK:\xae{\xfb{M\x96\xdc\xabY\xd1-\x93\xda\xb9y\xe5\xeb\xdb\xf7\
3881 \x13V\xa4\xd5R\xd3\xebgUdQ-\x17\xaa!\x0esf\xce6\x80\xe3\tUMo]\xddl\n\x97n!\r\
3882 \xf7\xf6\xb5\xcb\x94\x9b\xa6EG\xb2d\xd9\x80\x07\xb6\x9e\xfe\x1f\xf2\xc7\xc7}\
3883 \x10&n\xec\xde\x07\x08\xd4\xfa\x0c\x100\x80\xbf\xdc\xb9y\x88\x95UXZ\x00\x00\
3884 \x00\x00IEND\xaeB`\x82'
3885
3886 def getSEBitmap():
3887     return BitmapFromImage(getSEImage())
3888
3889 def getSEImage():
3890     stream = cStringIO.StringIO(getSEData())
3891     return ImageFromStream(stream)
3892
3893 index.append('SE')
3894 catalog['SE'] = ImageClass()
3895 catalog['SE'].getData = getSEData
3896 catalog['SE'].getImage = getSEImage
3897 catalog['SE'].getBitmap = getSEBitmap
3898
3899
3900 #----------------------------------------------------------------------
3901 def getSGData():
3902     return \
3903 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3904 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3905 \x00\x01\'IDAT(\x91\x8d\x92=JCQ\x10\x85\xcf\xbd\xefB4$\x9d\x8d\xf8\x93\xd2"\
3906 \xae +p=\xda\xbb\x96\xac!U\x8a`\xd2)i\x14L\x1f\x02\x82\x88(\xa4\x9183\xef\
3907 \x1c\x8b\xa7\x82\x8a\xe2\xc7t\xf3\xcdi\xe6\xa4\x07\x80@\xd9\xde\x86Y\xd45\
3908 \x01\x02\x00\xf8c\x02\x00P\x08\xec\xcc\xe7\xd5\xf1\xb1\xcdf\xbc\xbd\xcd\xfd>\
3909 \xd7\xeb\xb8\xbaR\x84"\xe0\xce\x08\xb9+B\xeew\xa3Q\x01P\xf5\xfb~y\x19\x93I99\
3910 \xd9\x0c\x87\xf9\xf00\xed\xed\xfb\xf4B\xee2\x97\x1b\xcd\xe4^\x1d\x1c\x04P\
3911 \x00\xa8\xae\xab^os\x7f\xcf\xf1x\xeb\xecL\x11/\xe7\xe72\xa7\x9b\xdcd.3\xb9\
3912 \xd3\x9d@u\n\xb4\x06\x83|t\x04)\xaeo|6{\x1d\x8f\x9bl\xba5\xaa\xcc\xe8\x9e\
3913 \xbb\xdd\xc7\xd5\xaa\x14\xa0^,l:\x15\x12:\x1dD+\xb7\xdb\x8c\x80{vo\x82\x11\
3914 \x91<\xd2\xeen\x01\x92\xaf\xd7\xb9\xd3\x91$\x08\x82~\'\xe7\xfc\xb4\\\x16\x02\
3915 I\x92\x04\xfce7\xdb\x00\n\xc9\n\xf8\xcf\x01\x00D\x14\x92\x9f6>H)\xe1\x0b\tP\
3916 \xf3\xcd\x02r\xf3\xfc\xccw\x82\xc1o\x80\x0c\x12d\xd3\x807\xec`N\x0c\xb9\xb5\
3917 \x8e\x1e\x00\x00\x00\x00IEND\xaeB`\x82'
3918
3919 def getSGBitmap():
3920     return BitmapFromImage(getSGImage())
3921
3922 def getSGImage():
3923     stream = cStringIO.StringIO(getSGData())
3924     return ImageFromStream(stream)
3925
3926 index.append('SG')
3927 catalog['SG'] = ImageClass()
3928 catalog['SG'].getData = getSGData
3929 catalog['SG'].getImage = getSGImage
3930 catalog['SG'].getBitmap = getSGBitmap
3931
3932
3933 #----------------------------------------------------------------------
3934 def getSIData():
3935     return \
3936 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3937 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3938 \x00\x01FIDAT(\x91m\x8c\xb1jTa\x10\x85\xcf\x7f\xef\x0f\xca\x16\x81\xa0`\x16;\
3939 \xb1\xd4J-\xad|\x05\x0b\x11\x1fC\xb0S,\x02v*\n"\xd8\xa8Ez;[}\x03\x1b\x1b\xb1\
3940 \x89EX\x85\x84\xcd\xbd\xba\xfc\xe7\xcc\x19\x8b\xbb\x86U\xfc\x18\xbe93\x03S\
3941 \xc6q\xc4\x06\xb6\'o\x86\x13dW\x00\xb3\xd9,\x13\xabU\xa0\xe4\xect\x0f\x00\
3942 \xc8\xcc\\\xb7\r\x86a\xa8\xd3\xe3\xc7\xcf\xf7\x0f\x16\x87\xbdc\xf7\xe1et]\
3943 \xfe\x8fR\x8a\xed\xd2o\x7f|\xf2\xe8\xc2\xf1\xb1n\xdf<\xf3\xea\xedb\x18\xc2\t\
3944 \xc9\xa2\xa9\x94L\x99\xb4\xe4\x9ds\xa7^>\xfdP\xe3p\xd8\xff\xb6\xba\x7f\xedKl\
3945 ]\xbfw\xe9\xf3\xad\xd7;DO\xb9\xd1ln4\xe9\xd6L\xc6\xd1\x92\xc0\x8f\nX\x897{\
3946 \x8b\xb3\xef\xf6\xc4`\x9eo\x99TR\xd9\x94m\n\x91\x14\x14\x00\\\x81\x1a\xee\
3947 \xde\xf7W\xdb\x91E3\x93tS\xd7\x02\x0c\xb4(k\x1bt\x07\xd4\xba\x8b;7\xc6\x07\
3948 \xcb\xe5\x81\xa5h2\xff\x98\x8c\xa6\x90\xdcd)\x18[\xdb\xf3gxQ\xef\xe2{\xff\
3949 \xeb\x93\x7f~\x05\x99d\xb6\x96\xad\xad\xc3\xc9F\x84\xa2\xac.^\x01\xaa\x81\
3950 \x8e\xc2|\x9e$\x14\x10A\x16\x12\x12&K\x88\x98\xca@\x19\x01o\x14\xfe\x1e\xff9\
3951 \x01\xf8\r^\x88\\1\x86\x01\xff\xc6\x00\x00\x00\x00IEND\xaeB`\x82'
3952
3953 def getSIBitmap():
3954     return BitmapFromImage(getSIImage())
3955
3956 def getSIImage():
3957     stream = cStringIO.StringIO(getSIData())
3958     return ImageFromStream(stream)
3959
3960 index.append('SI')
3961 catalog['SI'] = ImageClass()
3962 catalog['SI'].getData = getSIData
3963 catalog['SI'].getImage = getSIImage
3964 catalog['SI'].getBitmap = getSIBitmap
3965
3966
3967 #----------------------------------------------------------------------
3968 def getSKData():
3969     return \
3970 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
3971 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
3972 \x00\x01\x80IDAT(\x91e\x8e\xbfK\x95q\x14\xc6\x9f\xef{_oz\x8d,D\\\x1c\xa2\xff\
3973 "!"Qj\xe8\x0f\xa8\xc1\xa0p\xca\x1c\x1a\xeaB\xd1\xd4\xd6\xd4 \xd4TC\xa8\xa3D6\
3974 4\x88\x05M\xfd\xd8\xcc(\xc2Eo\xf4\xdb{My\xaf\xf7\x9c\xf3<\r\xafH\xd6\x87\xc3\
3975 \xe1yx8\x0f\'\xc5v\x01\x10{\x90\x04@\x90di\xb8\x87\x93\xc8\x01d\xb5\x1a\x00I\
3976 \xe5I&\x00JR\x05\xd0~\xb6\xbe\xfd\xc8\xcb\xfa\xe2\xe1#lnI\x94\x07\xc0\xee\
3977 \xabS\xfa\x8f\x94\x92\xbb\xe7#\x13\xebS\x17\x06N\xaf|\xec\xddh\xe8\xe6-\xcc\
3978 \xcd\xc6\xbb\xf7\xd3\x0f\x1amV\xc2\x19A\x0f\xb9\xd3\x83\xfd\x87\xf3\xfa\x95\
3979 \x95\xfc\xe5\xab\xe6\xd8H\xffX\xbb\xad\xcb\x93\xe8;\xa4\xf1\xf1\xb8~\xe3\xe7\
3980 z\xebC\xb3\x1b\xee\xe6\xb4\x90\x1b;\xce\xa1\xc1*\xe2K\x16\x0eQ\x0c\xea\xfe\
3981 \xb4Z\x9b\x9a\x9b\xc92\xfd\xeedNY\xc0\x03n2\x87\x07\x82\x00\x90\x03U\x89k\
3982 \xe7&\x17\x16>7\xee\x15\xd89s\xed\xfc\x89\xaf\xcf{,\x18\x941\x992\x17\x9diG\
3983 \x15\xa0\x9a\x96\x80c\xf5;]}\xb5\xe2\xe4\xe8\xed\xc7]\xf5\xb3^[|\xdaz\xf1\
3984 \x9a\xe64\xa3\xd9\xeeO\xe6\x07\x8e\x0e--\xce\xe4\xc3@e\xe3\x13\xdf\xae\xe2\
3985 \xd7\xea\xdd\xe3\xa7\xd2\xb37\xd5\'\xf3\x03f\xeatd\xa6R\xb8\xc1#\x1dl\x1e\
3986 \x01R\x01\xe4\x17/\xc9Mf\xf0\xd8\x15frW\xb9\xdd\x15\x81\x08D|_^N\xdb\x00\xff\
3987 \x1a\xec\xb7\xffD\x00\xfe\x00K\xdfG\xb9H4\x87\xd3\x00\x00\x00\x00IEND\xaeB`\
3988 \x82'
3989
3990 def getSKBitmap():
3991     return BitmapFromImage(getSKImage())
3992
3993 def getSKImage():
3994     stream = cStringIO.StringIO(getSKData())
3995     return ImageFromStream(stream)
3996
3997 index.append('SK')
3998 catalog['SK'] = ImageClass()
3999 catalog['SK'].getData = getSKData
4000 catalog['SK'].getImage = getSKImage
4001 catalog['SK'].getBitmap = getSKBitmap
4002
4003
4004 #----------------------------------------------------------------------
4005 def getSNData():
4006     return \
4007 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4008 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4009 \x00\x01+IDAT(\x91U\x911j\x96a\x10\x84\x9f7\xf9AA\x04\x1b1\x11b\x91.\x95\x9d\
4010 vv\x16v\x1e\xc0B\xb0\xf4\x08\xa9r\x03o"\xa4\xf1"v\x82\x85h%\xd8\x18\x15wfw,\
4011 \xbe_\x83\xc3\xb4\xcf\xec\xb0\xb3\xb8\xe0Z\x83^rp\x00\xc3l6s\xc6p\xed\x1dp\
4012 \xfe\xec\x1c\x98\xccd\xd6\x83\x86\x06\xaf_>\x1c\x1f\xdcT^8R\xecHW\x97\x97;\
4013 \x00\xf2\xf9\xc7\x97N\xf74\x11\xab\x13\xe5\x86\x12e\x94\x0f\x95\xaaH\xeb\xe4\
4014 d`\xc70\x93\x9ev\xda\xa3\xd0\xa4\x12w\xb4RI\xa5\xb4\x01H{\xa0i\xc7n{\x9c\xe8\
4015 Jz\xfbQ\xbf[\xcfO\xeb\xce\xe1\x7f\x00\x1b\xe0i\xb5<\xf6\x98\xe8\xfd\xb7z\xf7\
4016 I\xdf\xa5\xfb\xb7\xeb\xe9=\xa5\xf6\x95\xb0\x07v\x98\x1e{\\Sn\'zt\xb7\x1e\x1f\
4017 \xe9g\xd5\x93#e\xae/\xac}%\xa3\xa8\xba<VW\x10\xa9\xd7gJ\xd4\xa9\x8c\xfe\xc5\
4018 \xc7\xf6\x06\xb8\xad\x96Fj%E*QR+J\x94\xaaX\xb8\xe9\x06v\x14\x1a\x1f\xdf:V\
4019 \xcb\xdb[\xd1Z\x02\x83X\xe6\xd4to\x1eX\xbc\x82\x02CA\xf1\xf5\r\xf0w\xe6a\x8a\
4020 y\xb8\xdfx\xd3\x1f\xfe,[\x91A\xea\xa2\xe8\x00\x00\x00\x00IEND\xaeB`\x82'
4021
4022 def getSNBitmap():
4023     return BitmapFromImage(getSNImage())
4024
4025 def getSNImage():
4026     stream = cStringIO.StringIO(getSNData())
4027     return ImageFromStream(stream)
4028
4029 index.append('SN')
4030 catalog['SN'] = ImageClass()
4031 catalog['SN'].getData = getSNData
4032 catalog['SN'].getImage = getSNImage
4033 catalog['SN'].getBitmap = getSNBitmap
4034
4035
4036 #----------------------------------------------------------------------
4037 def getSVData():
4038     return \
4039 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4040 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4041 \x00\x01<IDAT(\x91U\x91\xbfj\x94Q\x10\xc5\xcfu?\xf7\xd3\xf4\x11V\x88\x08\x89\
4042 \xa4H!\x01S\xfa^\xa2\x90\x07H\x936>\x89E\x8a\x80\x10B\x12Ro!6\x16!\xa8\x08.\
4043 \x86\xc8\xbd3\xbfcq\xb3K\x1c\x86\xe10\xcc\xbfs\xa6\xe8\xf5\\U\xf7\x06\xaa(P\
4044 \x95*\xaa\xa1\x8a\x1a\x12R\xf48\xa8\xea\xf0\xc3\xb3^\x0c\x02"\x958!S\x11\x8e\
4045 t\x04\x1d\x1c\xed\xcf\x07A\xa2\x9b\x9f\x01\xcet\xa4#\x9d\xe9\x16\x8e\xa0\x85\
4046 [\xb8\x05\xad1[\x7f,\xd5rry\xbb\xb91\xad\x15[\xb6\xe9\x0eF\xb6\xc0`\x0cx\x9c\
4047 >\xfa|\xfe\xbddf)E\x92mY\x96m\xff\xfa\xb2\x7f\xcb\xf8|\xeb\x9d\x1fX)e\xb1X\
4048 \x0c\x9dmOup5\xbf;\xff\xfa#ho\xee\xfe\xec\xed\xac\xad\x1aT\n0\xac\xaaW\xf3w\
4049 \xb7\xa7\x8b\xf66\xc9\xbd\x9d\xa7\xffm\xb0\x81r|\xf6\xfb\xd5\x8b\xf1o\x05l\
4050 \xbb\x1f\x1dN\x90,pg\x80\xfdd\x9c\x1c\x9f^\x17\x8d\x97\xef\x0f6\xbe\xdd\xd4\
4051 \xa5&\xd4p\xa6[\xa3\xb5\xec*E\x12\xe9\x97\xb3\xe9\xa7\x8f\x17\x83\xc0\xd6l}h\
4052 \xe1\x0c"\x1d\xe1\x96D\x121\xc9\xbc\xd7\x1a\x9cH\xa2hr\xaa\xd4\xea\x91\xcb\
4053 \x18K\xcc\x03\x80\xa4\x7f\xa4XlM\xcd\x85\xad\x8d\x00\x00\x00\x00IEND\xaeB`\
4054 \x82'
4055
4056 def getSVBitmap():
4057     return BitmapFromImage(getSVImage())
4058
4059 def getSVImage():
4060     stream = cStringIO.StringIO(getSVData())
4061     return ImageFromStream(stream)
4062
4063 index.append('SV')
4064 catalog['SV'] = ImageClass()
4065 catalog['SV'].getData = getSVData
4066 catalog['SV'].getImage = getSVImage
4067 catalog['SV'].getBitmap = getSVBitmap
4068
4069
4070 #----------------------------------------------------------------------
4071 def getSYData():
4072     return \
4073 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4074 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4075 \x00\x01\x0cIDAT(\x91\x9dN=K\x03A\x14\x9c\r\xd7\x86\xd4)R\xa8\x87\xbfGE\x10\
4076 \xd1:\x7f"?$\xa5`\xa5\x87\x10H\x19A\x7f\xc3\x15V9N"\x11m"\xdc\x11\x0c\xd9y\
4077 \xfb\x9e\xc5&\xa7B\xb0px\x0c\xf3>fw\x9c\xe1\x1b\xfa[\xef,g\x00\x06\x03\x00\
4078 \xa6\nU\x84`\x12\x10\xc4D b\xa4\xfd\xe0\xe5x\x9c\x00\x00\xcc\xe6\xaf\x08\x01\
4079 !\x18\x19yS\x9eFo\xde\x1b\xe9z=\x05\x92\xba\xaa\xda\xed66>\x8b\xbc\x13p\xeec\
4080 6k5\xa1\xcdl\xa5\xeb\xac\xbc[\x19\xe3\x85\xb7p5\xbd\xaee\xd9xT\xb5\xa5\xaa\
4081 \xcd\xab\xa3\xe7\xd1\xe3\xfc!\x9b\xde\xc46+n\xef_&\xc3\xa7\xe1\xf6\x0b\x88H\
4082 \xa2M\x06\xd8\xc9\xdeQ\xbd\xaeN\x0f\x8e\xe3\xe0|\xff\xec\xfd\xf3\xed\xf2\xf0\
4083 "\xb6\xce\x0c\x80[,\x16\x9dN\xe7\xef\xf4q\xeb\x9c+\x8a\xc2\x01\xe8\xf7\xfbeY\
4084 \x92$\xe9\xbd\xf7\xdeGA2*\x11\x8a\x844M\xf3<O\x00\x90\xd2\xedvI\x8a\x04\x91h\
4085 \xa4\x88D\x16\x91\xb0\x05\xfe\x81/=\x07M\x1d\x06\xbc\xc3+\x00\x00\x00\x00IEN\
4086 D\xaeB`\x82'
4087
4088 def getSYBitmap():
4089     return BitmapFromImage(getSYImage())
4090
4091 def getSYImage():
4092     stream = cStringIO.StringIO(getSYData())
4093     return ImageFromStream(stream)
4094
4095 index.append('SY')
4096 catalog['SY'] = ImageClass()
4097 catalog['SY'].getData = getSYData
4098 catalog['SY'].getImage = getSYImage
4099 catalog['SY'].getBitmap = getSYBitmap
4100
4101
4102 #----------------------------------------------------------------------
4103 def getSZData():
4104     return \
4105 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4106 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4107 \x00\x01\xc6IDAT(\x91%\xd1MK\x94a\x14\x06\xe0\xfb}\xe7\x99\xc9\x9a\xa2,BJ\
4108 \x9aM\r\xd2\xa2\xa0\xc0e\x10\xa66\x05\xb6k\x13\xb4\xae\x08\xda\xe8\xa2\xc2A\
4109 \x90\nj\xd3w\xab\n\xd4EQDQ\x11D\xd2\xca]$\xf4e\x81A\x81\xa3\x8b\x90\xf0k\xc6\
4110 w\xces\xce}Zt\xfd\x85+9~\xfdC#S\x00\x00H*!\xa4*U(\xaa\xa2\xccTET\x94\x99hKH\
4111 \x03\xc3\xd2\xe9J\x19\x00\x1ct\xa7\xbb\xbb\x9b\xd1\xd4\x08\xd0a\xa4\xd1\x8d4\
4112 \xb2\x7ft"\x8c\x16z\x0b\xf9\x9b\xbe\xfa\xc7I\xb89\xcd\xa9NsW0\xba\xa93\xbaER\
4113 \xd3\xb5m=\xe1n\xb8u\xcaz.\xcc.\xcf\xcc\xb8Y\xf0\xf8\xbbio\x1cQel\xe4\xe1\
4114 \xca\xb7/\x9f\xef\xdcX\xfc5kQ\xb2fl-\x95\xee\x8f#%\x10\xcd\x90h\xb9k\xdd\xe6\
4115 \x83\xc5\xd7\xa4&i\xb3)S\xd3?[:v\xef\x1c\x1c\xea8\xb1\xbds\xe4\xc1\x0f\x91\
4116 \x18\xe3\x02\x90*\x90\xc0J\x95m\xab\x9b\xb6\x0e\xbf\x9a\xef\xeb;z\xecHw\x8c\
4117 \xb1^\xaf\x0f\x9c\xaf\xbe\x18\x7f_\xec<;\xfd\xf2\xe2\xe13\xfbC\x91\x02\x04\
4118 \x05\x80t";$\xb9\xd6n\x99|\xfc\xe8\x89\x9aeY\x16B\xa8\x0e\r\xd6&?}\x1c\xa8~?\
4119 p\xb2\xb1\xa1\xbcw\xe1\xb2\x02!\x05Lm\xcb\xf3{\xeaX#\xcdJ\x8c\xefD\x16b\xcc\
4120 \x1b\x93\xa9\xafs\xd7\xae\xfc\xad\xcd\xb5\x8d]\xd24\x97\xb4\xb7\x03H\x16\xaf\
4121 \xa2\xd05\xcc\xe5\x9a[t\x8f0#\xa3Y\x04\xcdM@!\xd5M\xdd\x186\xee\xa8\xdd~\x16\
4122 z\x1bO\xcf\xc9\x1e\xe6]s$\xa99w:I\x91\xc8\x1c\xe8nt\xa3\xd3\xe9\xe2\xd5lW\
4123 \xb2\xaf\xff\xed\xfcR\xf6?2\x13\x15\xa1\xabB\x14\xa2\xa0B\x08!TAB\x89\xf5\
4124 \xe1\x1f$\xeeaN\xbc\x0e\xd5\xeb\x00\x00\x00\x00IEND\xaeB`\x82'
4125
4126 def getSZBitmap():
4127     return BitmapFromImage(getSZImage())
4128
4129 def getSZImage():
4130     stream = cStringIO.StringIO(getSZData())
4131     return ImageFromStream(stream)
4132
4133 index.append('SZ')
4134 catalog['SZ'] = ImageClass()
4135 catalog['SZ'].getData = getSZData
4136 catalog['SZ'].getImage = getSZImage
4137 catalog['SZ'].getBitmap = getSZBitmap
4138
4139
4140 #----------------------------------------------------------------------
4141 def getTHData():
4142     return \
4143 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4144 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4145 \x00\x01\x0eIDAT(\x91}Q\xb1JCQ\x14\xcb\xb5\x0f\x8aT\x1d\xaa\x8bS\x17urq\xd0\
4146 \xdd\xc1\x8f\x11\x1c\xab?\xe0\xcft\x15\xbaIq/~E\xf7:\xd4\n\xf6\x9e$\xc7\xe1A\
4147 k\xa1\x1aB\x08g\x08\xe1\xa4$6\xf0\xb6\xdf\xc9\x92\x00\x9e\x9f\x01\xa4\x05\'\
4148 \xc8t\x82\x91\x12\xc8$3"#\x92Lr9\x1a\x95\xcc\x04\xd0\xea\xda\xe4.\x94R\x16\
4149 \x8bE\xb9\xbd{y\xb8\xbf\xfc\xf8X\xc9i\xa5l\xd1T\x8a\xa2,Z2\xc3\xb4\x8f\xfb\
4150 \xfbO\x8f\xe3\xe6\xed\xf5\xfd\xfa\xead6\xfb$\xcdp\xd0\x11\x8aP\xad\x8eP\xadZ\
4151 \xeb`p\x04\x8c\x1b\xc0mO2\x19\x19\xccZ\xdb\xda\xae\xd552\xaa\xdb\x0b\t\xc0\r\
4152 \xf0-\x91\x8c\x1afh\x1d\xff;\xbbVE8\xa2\x02\xcb\xa6wxqv\xde?8\xec\x92I*h\xd2\
4153 \x0c\x91\x0e\x9a\x14i\xd2\x92OO{\xd3\xe9MY\xadV\x9dN\xc7\xf6_\xcfi\x01\xa0\
4154 \x942\x9f\xcf\x1bw\xbb{\xc3!\xda\x8e\x12\x82\x10K\x04\xc8\rmH\x90<\x99\x94\
4155 \xaf\xed!\xff\xd9\xb8\xc5\x0f_\xffe\x8c$1\t^\x00\x00\x00\x00IEND\xaeB`\x82'
4156
4157 def getTHBitmap():
4158     return BitmapFromImage(getTHImage())
4159
4160 def getTHImage():
4161     stream = cStringIO.StringIO(getTHData())
4162     return ImageFromStream(stream)
4163
4164 index.append('TH')
4165 catalog['TH'] = ImageClass()
4166 catalog['TH'].getData = getTHData
4167 catalog['TH'].getImage = getTHImage
4168 catalog['TH'].getBitmap = getTHBitmap
4169
4170
4171 #----------------------------------------------------------------------
4172 def getTJData():
4173     return \
4174 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4175 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4176 \x00\x01;IDAT(\x91\x8d\x8f\xbdN[Q\x10\x84\xe7\\\x9b K\x96\x0c\x15\xe2\xc7I\n\
4177 \\\xf1\x04\xf4<\x0b\x05\x05\x1d\x12\x92\x83\x92\x86"Ux\x16^ E\x9a\xb4\xf4\
4178 \x91-G\xb8\xa1\xc2\x85\x11:3\xbbCq\xe1\x862\x9fV\xabYi4\xda)?\xf1\x8f\x04\
4179 \x12\x00 @og\xa7[\xd1\x070\x99N\x018\xd3\x99\x88\xb0"C\x96,\x99L\xc9\xa4\xa5\
4180 $\x7f\xdd\xde\xf6\x01\x00\xae\xf7KG "\xc9\x8c0\x99\xa4\xc9\xacLV\xd7\x9a\xe4\
4181 \x87\xf1X@Y\xaf\xd7\x83\xc1\xa0}\xc96\x80\xfa\xe7[3<2z\xb1\xfa\xdd\xfb<u\x19\
4182 \xd8\xb6]JY.\x97MW\xc06\x0c.n\x9a\xadc\xc7\x93\xf5\xd8;8\x8b\xbf7~\x87\xa4&3\
4183 [\xb7m.~\xf4\xc6\xe7e\xfb\xc4\x96S\xde\xd8+\x1f/c\xf6\xf5\xd5\x0edfY\xadV\
4184 \xc3\xe1\xd0m\xbea;\x16\xdf\xfd4s\xca\x9b\xfb\xe5\xd3U\x17\xdf4\xcd|>\xefw\
4185 \xf1\x9d(\xe3\x0b\xd8\xedtt\r\x0b&8\xfdr:{\x98Qd\xb0\xaaVU\x8a5*\xc5*2\xaa\
4186 \x82\x8a8\xdc9\xbc\xbb\xbe\xeb\xe3\x19\x0c\xed\x8ev\x19T\x84\x82\x0cRT\xaa\
4187 \xdd\nEFDD\x06\x00`\x07\x18\x01\x9b\xf8O^\x00!\x0e:$\x8c\xf3]\xab\x00\x00\
4188 \x00\x00IEND\xaeB`\x82'
4189
4190 def getTJBitmap():
4191     return BitmapFromImage(getTJImage())
4192
4193 def getTJImage():
4194     stream = cStringIO.StringIO(getTJData())
4195     return ImageFromStream(stream)
4196
4197 index.append('TJ')
4198 catalog['TJ'] = ImageClass()
4199 catalog['TJ'].getData = getTJData
4200 catalog['TJ'].getImage = getTJImage
4201 catalog['TJ'].getBitmap = getTJBitmap
4202
4203
4204 #----------------------------------------------------------------------
4205 def getTMData():
4206     return \
4207 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4208 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4209 \x00\x01\x8fIDAT(\x91\x85\x8e?kSq\x18\x85O.\xf7\xde\xdc\xa4\xf6\xcf$\xad8h\
4210 \x17\x07q(H\xc5\xc9Qp\x94\x8e."\xfa\x05\x82\x14\xa4\xbb\xa3:\x16\xfa\r\x9c\
4211 \x04A\xd0\xc5\xc1\xa9\xb4\x0eM\x0b\x1am\xd2`4X\xaa&&5\xb9\xef9\xef\xef:$\xb8\
4212 \xfa\x0cg;<O\t\xd7\x01\xe0\xcd\xcf\xa5\xde\xc7\xee\x10\xb8\xbb\x02\x083\xabW\
4213 N\xdf\xd6a\xc0\x18\xd3\xcd1!\x06\xb0Q{\xb2\xdc\xcd\x8bPN\x17\xaa\x0f\xd3\xde\
4214 L\xb9\xf2k\xd8\xbb]\xdb\xdam\x1d\xecw\x1ar1\x90r:_\xd46#\x00(\xf0\xfb\xe8k\
4215 \x94\xb7\x8fw\xde/T\xce\xec\xb5?\xccWg\x1f\xbf\xdc\\[\xbd\x99\xcb>}?jt\xdb\
4216 \x8doM\xba\x00D\x08\x08EH\xd2\xa2\xdf\x1d\xa5I\xd8i\x1d\xdc\xbb\xb1\xb6}\xb8\
4217 \xb7~\xebAT\x8a*I\xd9D\xa3\x99\x93"\x80\x18\x01\n>\x1e\xf0t\x94g\xa5B\x8e\
4218 \xd7\xf5wO\xefl\xd0\xfd\xf9\xf6\xab\xd6I\xc7H\x13)R\x02\x10\xc3\x10\x82\'\
4219 \x89\xff\x19\x86\xd9j0\xa9\xdei\xdc\xdfztiq\xb9y\xf2\xe5\xb8\xff\x83\xa2\x89\
4220 &M\x92b\x08\n>\x1aX3\xe3\\\x9f\x14\xcc\xcd\xa4\xdd\xf6>IsR2\x91\x92\x9cS\x83\
4221 \xe4i\xe2\x991\xab\x16&\x9b\x04\x98\x8b\x9a\x1e(\xd2\xe5\xc1\x01D\x18\x83As+\
4222 \xd7\xae\xa6\xc8.\\\xb6i\x00Mf2\xa3&=r\xc9\xfd\x9fA\x83\xc3F|\xf6\xa2\xf5\
4223 \xba\xe7\x96\x16%\xd1I\xa7\\\xf2 \x97\x07ww\x05\x01(a\x1e\x18\xe3Y\x8e\xf3\
4224 \xc0g`\x1d\xff\xe1/\x0b\xd0A&\xe7\xb8\xaev\x00\x00\x00\x00IEND\xaeB`\x82'
4225
4226 def getTMBitmap():
4227     return BitmapFromImage(getTMImage())
4228
4229 def getTMImage():
4230     stream = cStringIO.StringIO(getTMData())
4231     return ImageFromStream(stream)
4232
4233 index.append('TM')
4234 catalog['TM'] = ImageClass()
4235 catalog['TM'].getData = getTMData
4236 catalog['TM'].getImage = getTMImage
4237 catalog['TM'].getBitmap = getTMBitmap
4238
4239
4240 #----------------------------------------------------------------------
4241 def getTNData():
4242     return \
4243 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4244 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4245 \x00\x017IDAT(\x91}\x91\xb1JCa\x0c\x85\xcf\xad]\x05A(\x14[\x07\xa7\x8evq\xf2\
4246 \x01\xd4\xa1[\xa7\x82\xb3\xa3nB\xdf\xa1\xabN\xbe\x82\xe2\xe0$\xb6X\xe1.\xbat\
4247 \xed\xaa\xbbP]n\x92\xffs\xf8\x8bZ\x10C\x08\xe1\x90\x8f\x84\x9c\x02\xfdDZ\xed\
4248 \xff\xcc\x02I\xc3\xa1$RRJ\x8a\xc0C\xe1\xb8\xcb\x1d3~\xd5\x8f\xdb\xdb\xba$\t^\
4249 \xdf\x14\xa1\x08NN\xb4\xbd\xcd\xc6\x06\xc0tJY2\x1eSU\x98\x15\xedv\x92\xea\
4250 \x92H,\xa7\x8f\x8f\xb5Xpy\xc9|N\xbbM\xafGk\x8b\xee.\xd3'\xccd\x96\xa4Z\x92\
4251 \x14\x91\xb7+%\x1e\x1f\xe9t\xb8\xb8`s\x93\xb2\xe4\xe0\x10s\xaa*/\x91T\x93$\
4252 \x0f\xcc0#\x82\xf9\x9c\xa3#F#&\x13\xba]\xd6\xd71[\x02\xee)\x03\x84\xe3\x8eU\
4253 \xa4D\xab\xc5\xcd5\xa7\xa7\x0c\x06\x94%\xef\xef\xdf\xc0\xcfIY\x929\xee\xec\
4254 \xef\xf3\xfcB\xbf\xcfx\xcc\xde\x1e\xb3Y\xfe\x8f\xdcqw\xa9\x9e\xa4\xb5,\x991\
4255 \x1aq~\xce\xd9\x19\x8d\x06\xc0\xdd\x1d\xf7\xf7<<\xe0&\x0fE(\x035s5\x9b\x98\
4256 \xc9CWW2+\xcc\xe4\xae\\wv\xf2\x0f\x15\x91\xa4\xe2s\xd5\xc8\x7f<\xce\xf1\x05g\
4257 \x93;~\x84\xff\xbb8\x00\x00\x00\x00IEND\xaeB`\x82"
4258
4259 def getTNBitmap():
4260     return BitmapFromImage(getTNImage())
4261
4262 def getTNImage():
4263     stream = cStringIO.StringIO(getTNData())
4264     return ImageFromStream(stream)
4265
4266 index.append('TN')
4267 catalog['TN'] = ImageClass()
4268 catalog['TN'].getData = getTNData
4269 catalog['TN'].getImage = getTNImage
4270 catalog['TN'].getBitmap = getTNBitmap
4271
4272
4273 #----------------------------------------------------------------------
4274 def getTOData():
4275     return \
4276 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4277 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4278 \x00\x00\xf6IDAT(\x91uRAn\x021\x10s\x96=V\x8b8r\xe0\xc8\x8d\xe7\xf0\r\xa4\
4279 \xb6|\x81\xf6\x17\xf4\x01\x1cy\x0f\x12\xed\x13V\xa2\x87\x8e\x9d\xb8\x87,hWj#\
4280 \xcbR\x14\xdbq4I}\xdfc\xb4J\x01P\xba\xc5\xa2\x00\x7f\xa2\x05\xd0u\x1d.\x17\
4281 \x9fN\xd8n\xb1^\xdb\xc0n\x97\xa4\x99\xd4\x90\x96|\xe7\xdb\xf9\xdc\xd6`\x1f\
4282 \x0e\xc8\x19o\xef\xfe8"%_\xaf&M:h\x86#L\xa6\xd5\xaa\x00\r\x00\xdb\xd8\xef\
4283 \xd1\xb6~y\xae\xdbA\x1aa\xfe8b\x009T\x02\x80\xcd\xc6\xc7#\x0c\xc3\xb6\x1d1\
4284 \xce\xae\x0c\x12@\xfb4\x9f\xe3u\xef\xafOK\xa0\xac\xe1\xf8\xa1{\xc4C\x1anp\
4285 \x96%3@\x995\x98\xe3\xec\xe1\r\xb5R\x01\x12\xe9\x08H\x13\xd1T\r\xc9\x92\xaaa\
4286 &\xd5\x8a\xe3\x02\x13\x9b\x08e\xe4\x8cjh(,\x97&\xa1\x0c\x11d"!\xa1\xb2\x84\
4287 \x9c+\n\x90\xbe\xa7\x83\xc4?\x03.\xf7\xaf\xf0\x0b\xfe\x1dN\xdfm\x87\xb5\x86\
4288 \x00\x00\x00\x00IEND\xaeB`\x82'
4289
4290 def getTOBitmap():
4291     return BitmapFromImage(getTOImage())
4292
4293 def getTOImage():
4294     stream = cStringIO.StringIO(getTOData())
4295     return ImageFromStream(stream)
4296
4297 index.append('TO')
4298 catalog['TO'] = ImageClass()
4299 catalog['TO'].getData = getTOData
4300 catalog['TO'].getImage = getTOImage
4301 catalog['TO'].getBitmap = getTOBitmap
4302
4303
4304 #----------------------------------------------------------------------
4305 def getTRData():
4306     return \
4307 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4308 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4309 \x00\x019IDAT(\x91}\x91=JCQ\x10\x85\xcf\x8b\xb1S\x03\xb1\xb2\xb0\x10\xc1\xc6\
4310 \xda, h:\x17 v.\xc1\x05X\x077`\xafE,,$U\xaa\x94\x81`\xe7\x12bV\xa0y\xa0wf\
4311 \xeegq\x1fh@<\x0c\xc3\x14\xf31?\xa7B?\xca\xeb\xf5\x9fQ!\xe9\xe6F\x11\xe4\xac\
4312 \x9c\x15\x81\x87\xc2q\x97;f\xfc\xca\xab\xf1\xb8-IU\xc5r\xa9\x08E0\x18(g&\x13\
4313 \xde\xdf1#\x19\x96H\t\xb3j\x7f?KmI\xe4\xdct_^\xea\xe4\x043\x0e\x0f\x19\x0eI\
4314 \tK$+\x80\xcc\xb2\xd4\xca\x92"\xe4\xce\xc1\x81\xfa}\xee\xee\xb8\xba\xe2\xf9\
4315 \x99\xbaf4bk\x1b3R3DRK\x92>\xbf0\xe3\xf4\x8c\x08f3R\xe2\xe5\x85\xc7G\xba]\
4316 \x9e\x9e\xe8\xf5\x1a\xc0=\x17\x80p\xdcY\xbe!q|\x8c%\x8e\x8ex}e8d\xb1`:-@Y\
4317 \xa9\x9d\xa5\xca\x8c\x94\xf4\xf0\xc0\xce\x0e\xd7\xd7\xd45\xc0\xc5\x05\xab\
4318 \x15\xf7\xf7\xcd2\xee\xb8{\x016\xdc\xcbM\xdc\xder~\xce\xe6&\xa3\x11\x1f\x1f\
4319 \x985\x07\xb8\xc9C\x11*@\x0b\xb4\xb7\x87\x99<4\x9f\xcb\xac\xda\xddU\xa7#3\
4320 \xb9\xcb\xbd\xfcP\x11Y\xaa\xeau#\xff\xf1\xb8\xe8\x1b]@>O\x98\xdeiy\x00\x00\
4321 \x00\x00IEND\xaeB`\x82'
4322
4323 def getTRBitmap():
4324     return BitmapFromImage(getTRImage())
4325
4326 def getTRImage():
4327     stream = cStringIO.StringIO(getTRData())
4328     return ImageFromStream(stream)
4329
4330 index.append('TR')
4331 catalog['TR'] = ImageClass()
4332 catalog['TR'].getData = getTRData
4333 catalog['TR'].getImage = getTRImage
4334 catalog['TR'].getBitmap = getTRBitmap
4335
4336
4337 #----------------------------------------------------------------------
4338 def getTTData():
4339     return \
4340 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4341 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4342 \x00\x01\xd1IDAT(\x91M\x8b\xbfK\x1ba\x1c\x87?\x97\xc3%\x9ed\x0c\x19\xb2\x04\
4343 \\\xdb\x8a`K\xa0\r\xa5\x05\x83\xb4\x1d:\x0878(\x15\x11\x94\xd0.\x0ei\xab\xff\
4344 \x81\xffBWW7\x8988i\xb8&\xf68{$\xef%w\xc9K"$\xbd\xab\x8d\xe6\x87\xf7&\xef\
4345 \xb7SK><<\xf0\x0c\x1fL\xba\xddD"\x01\x00@<\x1e\x9f\xb4Z\x13]\x9f\x00\x02x\
4346 \x00\x86@\x1f\xb8\x03\xfe\x00\xbf\x01\x1fPh~\x9e\xae\xae\xbe\x1d\x1d1\xc6\
4347 \xa4\x94\xa9T\xea\x83\xae\xe3\xec\x8cNN0\x1e\x93\x104\xe5\xfb\xe3c\xf5 \x08\
4348 \x94L\xe6I6\xfb\xdd4\xab\xd5*c\xccv\x9c\x17\xab\xabt{K\xe7\xe7\xd4\xfdE\xdd.\
4349 u:\xd4\xe9(\x9a6r\x1c\xf5\x00\xa0d\x12\xbd\xbb\xb4\xae\xdb\xb5Z\xbb\xdd\xe6\
4350 \x9c[\x8c\xbd\xdc\xd8 )\xa9\\\xa2PP\x18\x92\x10\x98\x9b\x1b\xd5\xeb\xeaW@I\
4351 \xa7qy\t\xa2\xe7kk\xd7\x8cq\xce9\xe7f\xa5\xf2zk\x8b\xa4$\xc3\xf8\x7fxh4\xd4}\
4352 @y\xfa\x8c\x82\x80,\x0bD\x99\xf5u\xb3Ri6\x9b\x8dF\xa3\xf4\xd3\xce\xee\xee\
4353 \x92\x94T,\x92\x10\x88\xc5F\x9c\xab\xfb\x00\x96\x96(\x08H\x84\xf8a\x82\xe8\
4354 \xd5\xe6f\xd9\xb6=\xcf\xf3<\xcf\xb0\xac7\x9f>\x92$\xba\xb8Pb\xb1a\xab\xa5~\
4355 \x01\xb0\xb8H\xbe\x8f\xf1\x98\xc2\x90\xcae"Z\xde\xde.\xd9\xb6\xeb\xba\xae\
4356 \xeb\x1a\xd6\xf5\xbb\xbd=\x00\xa8V\xefon\xd4\xcf@da\x81|\x1fB\x90\x10\x14\
4357 \x86d\x18\x04\xac\xe4r\x86e\xd5\xea\xf5\x9a\xe3\x14M\xf3}>\x8fHdX(\xa8y \xf2\
4358 \xe81f\xa3\x14\x8dbV\x83\xa6A\xd3\x14\xc7\x81\xa2\xbc\xcd\xe5\xda\xbe?\x18\
4359 \x0cz\xbd\x9e\xc9\xd8\xf2\xceN\xff\xf0P\xe9\x03r\nL\xe7\xcc\x8c<=Mf2\xf87V(\
4360 \xfc\x05\x9e\x045\xa0\xd9,m\xf9\x00\x00\x00\x00IEND\xaeB`\x82'
4361
4362 def getTTBitmap():
4363     return BitmapFromImage(getTTImage())
4364
4365 def getTTImage():
4366     stream = cStringIO.StringIO(getTTData())
4367     return ImageFromStream(stream)
4368
4369 index.append('TT')
4370 catalog['TT'] = ImageClass()
4371 catalog['TT'].getData = getTTData
4372 catalog['TT'].getImage = getTTImage
4373 catalog['TT'].getBitmap = getTTBitmap
4374
4375
4376 #----------------------------------------------------------------------
4377 def getTWData():
4378     return \
4379 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4380 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4381 \x00\x01\x11IDAT(\x91m\x91\xb1M\x03Q\x10D\xe7\xceg9E\x02\t\x1c8&!\xa2\x05j\
4382 \xb0(\x03\n\x80\x8c.\xa0\nS\x02\x14`Q\x80u\x04\x86\x04\x81@\xb6l\xfe\xcc\xce\
4383 '\xf8`|\x82\xd5h\x92\x9d\xb7\x1ai+\x1c\xdeb32d$c\xad\xc7\xb7\xd3\x03\xc0\x7f\
4384 \xd4\x00\xb8\xba<\x02p\xbc;\xe8\xd5\xf5\xfd|\x11FD\xecL\xcf{Z\xd6d\x96\xf2\
4385 \x8f/&\x93\xa6\x9c\xde[\xfad\xbc\xdf\xefW\xed\xf5\xe2\xeee%Y\xb3\xd6\xfc\xc8\
4386 \x89\x99)\xa7\x94\xc9j42\xd0\xc0\xb0\xcd\x14@&\xbdZ\x89a\xc9\xdfQ\xa6\x9cX\
4387 \x00\x90\x06\x1aH\x11\x98\xaeyq3\x93\xfd\xf4\xfe\xa90mo\xdd\xde\x00\x00\x1a$\
4388 \xd9\x0e\xc5\xf3\xab$3rDH\x1ep\xf1\x9b.\x80d\xa0\x89\xf9\x18\x0fg\xb9m3\x13\
4389 \xa8Ln\xd7\xd8\xf6\xaaT2P\x919%H\x9dP7\r)K*@O*\x15\xb7\x0bt0\x11\nD\xa0\x005\
4390 \x85\xe10\x93P@\x04Y\x91\x90P\\BD\x91\x81j\xd9}$\xfe\xfb\xeef\x05\xe0\x0bISf\
4391 \xe0\xc1\xf3\xe2%\x00\x00\x00\x00IEND\xaeB`\x82"
4392
4393 def getTWBitmap():
4394     return BitmapFromImage(getTWImage())
4395
4396 def getTWImage():
4397     stream = cStringIO.StringIO(getTWData())
4398     return ImageFromStream(stream)
4399
4400 index.append('TW')
4401 catalog['TW'] = ImageClass()
4402 catalog['TW'].getData = getTWData
4403 catalog['TW'].getImage = getTWImage
4404 catalog['TW'].getBitmap = getTWBitmap
4405
4406
4407 #----------------------------------------------------------------------
4408 def getUAData():
4409     return \
4410 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4411 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4412 \x00\x00\xf7IDAT(\x91m\x8cAJCQ\x0cE\xcf\xfb}\x08\x8a\xc3N\x94\n\xe2f\\\x8e\
4413 \x0bp\xec"\xdc\x86k\x10\x84\xee\xc0\x99\x82s\x1dX\xd0\x97\xe4^\x07\xfd\xad\
4414 \x16\x0c\xe1p\x13N\xd2\xb83\xfb\x92H\x10$\xa4\xe6\x1e;\x0e\x01\x1dq{\r [neR\
4415 \x94\x9cn\xa9Ej\x8ar\xca!G\xf9\xe1\xfe\xb33\x01\xbcm\\\xa6D\xc8U\x84\x1d5K\
4416 \xa3<\xe4(_\x9c6\xbe\xd4\x11\x92K\xa4I\xb9\x8aag9v\xde(\x8fr\x94\xa3\x00u\
4417 \x86\xca-E\xca\xb9\xff\xfd\xc7\x9e)\x87\xe0\x83\xcer\xbd<\xbe\x1c\xf5]rJ!R\n\
4418 )\xe4(\xa5\x145\xe7\xd5\xc9\x11\xe7\x8f\xad^auc\xbf\x98\x81\xd3\x0e{\xfc\xcb\
4419 i\xbaz\x7fZw\x89\xe6\xb0\x07\xe4\xa1t`C\xda\x99\xd0%\x16\xa4\x1d\xb0\x97\xfe\
4420 9\x83\x82"\xe9\x12\x93\x13\xcev\xdb\x80h- a\xcb\x9cmJ\xa2m\x9e\x91P\xced\x9f\
4421 \xb7\x81\xdf\x11\x01\xfc\x00H\x87n\xe8\xf8\xe8Xa\x00\x00\x00\x00IEND\xaeB`\
4422 \x82'
4423
4424 def getUABitmap():
4425     return BitmapFromImage(getUAImage())
4426
4427 def getUAImage():
4428     stream = cStringIO.StringIO(getUAData())
4429     return ImageFromStream(stream)
4430
4431 index.append('UA')
4432 catalog['UA'] = ImageClass()
4433 catalog['UA'].getData = getUAData
4434 catalog['UA'].getImage = getUAImage
4435 catalog['UA'].getBitmap = getUABitmap
4436
4437
4438 #----------------------------------------------------------------------
4439 def getUSData():
4440     return \
4441 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4442 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4443 \x00\x01\xb9IDAT(\x91U\xd1\xbdkSa\x18\x05\xf0\xf3\xd6\x04\x17Q(\x08\x16\xa9\
4444 \xc1\xc5\xd5M\xa4\xa0\xc5M\xed\xa0\x83 \xd5E\xbcj\x06\'1\x8b\n\xe2\xd0?@\xa4\
4445 \x83\x88\xd0V\x84:tphAAc-\x19,~,R\x0c\x85"$-\xf1&!\xb9\xb9y\xf3\xde\xf7\xf3y\
4446 \x1c\xa4\xa1\x9e\xe9\x07\x07\xcerDT\xac`\x18"\x90\x07,\xc0\x80}Q\xf8\xc0j\
4447 \xd0n\xfd\xb1\x00\x01\x04x\x00Q\xb1B\x14^\xadz\xc7v\xa1\xec\x9ds/?zc\xf4\xf3\
4448 \xf7\xdeZc\x8c\xd1:\xcb2\x95eJ)\xb9\xb44\'\xa2ber\xfa\xf4\xe2\x1a\x05B X\xcf\
4449 \x81\x11\x08\xda\xf3w<B\'A\xda\x83\xecC)q\xedB\xf5[\x05Q\xf1\xd3B\xd9\x1bc&\
4450 \x1f\xdb\xc1`0\xf1\xc0t\xbb\xdd\x93\xf7u\xae\xa4\xd34M\x92\xa4\xd3\xe9\xb4\
4451 \xdb\xed\x10\xaeK\x99\xae\xaf\x7f\x16\xd1\xed\xb5\xb3\xd3\x13se\n\xc4\x81\
4452 \xe1\x1d\x0c\xf3\x06\x8cW_}c\x16JAJ\xd6\x1a\xd6\x8e\xdc\xbc\xfce\xe3\x07\xa2\
4453 \xe8\x9ds\xee\xccC\xd3\xeb\xf5N\x95L\xab\xd5\xdawo\xa7^\xaf\xe3\xd2\xca\xbf\
4454 \xedf\xb3\x19\xc7q\xa3\xd1\xf8Eay\xf9M\x0e\xe0\xf9U\xe1=\xce\xcd\xec\'\xcfGf\
4455 T0\xd5\xf1;\x015:85\xc5Z\xc3\x18\x18\xc3Z\x1f\xbe{\xb5\xbaU\x15\xb5\xda\xd6\
4456 \xd8\xd81\xe7\x1c\x1113\x11\xed\xc5\xd0Y\x96\x1d\xcfc\xf6\xed\xeb\xdc\xd1\
4457 \xf9\xa7\xe2\xfc\x95\x91\x952\xc71\x92\x04RBJh\xcdJ\xc1Z\x1e\xc29*\xdd8\xb4\
4458 \xfd[ln\xfe,\x14N\xf4\xf3\xf9\x03V3\x83\x99\xf8\xffx\xef\xb4\x1e\x05\xb6C\
4459 \xa0\xd1gO\xc4\xce\xad\x8b\x81\xf7\x1c\xb9\x0b\r\xf4\x01\x05(\xc0\x01z\xb7\
4460 \xfd\x0bh\x80b\xaa\xc7\x98\x14\xc8\x00\x00\x00\x00IEND\xaeB`\x82'
4461
4462 def getUSBitmap():
4463     return BitmapFromImage(getUSImage())
4464
4465 def getUSImage():
4466     stream = cStringIO.StringIO(getUSData())
4467     return ImageFromStream(stream)
4468
4469 index.append('US')
4470 catalog['US'] = ImageClass()
4471 catalog['US'].getData = getUSData
4472 catalog['US'].getImage = getUSImage
4473 catalog['US'].getBitmap = getUSBitmap
4474
4475
4476 #----------------------------------------------------------------------
4477 def getUYData():
4478     return \
4479 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4480 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4481 \x00\x01bIDAT(\x91e\x91\xb1\x8a\x93Q\x14\x84\xcf\xbd\xb9\xb9\xc6B\xb2\x8b\
4482 \xc2\x16\xb2\xf8\x08\xb6\x96\x82/\xb0o`\'\xa8\xdd\x82\x8d\x0f\xb0\xbe\x82\
4483 \xb6\x8a\xa06\xc2\x8a\x88\x9d\x85\x85Xha\x88\n\xb2AYI\xb1\xfc\xca\x8f\x107\
4484 \xf9\xcf|\xc7b\x93(8\xcd\x999\xd5\xc7Lj\xdb\xd6\xcc\xcc\x0c,g\x033\x83\xf5\
4485 \xf9O\xc5\xccjui?%j\x7f\xc7\xd3\xc6\xc3\xb7\xcd\xf1\\X\x08\x93\xe8\x14"\\!\
4486 \xd8\xbb\xf3:5MS\xeb~\xce\xaf\xcc\x04\x97\xa2w-"\x85\xc5Z\xacL\xcey\xf4iR\
4487 \xc0\xe1w\xce\x8a\x90\xd9(\x85\xbf\x1c\xcf\x88\x10!BB\x84\x03\xc4\x99A\xef\
4488 \xd6\xfd\x83R\xeb\xa0\xf4v\xe6\x8b\xef\x81\x0f\xea\xf5E\xf4_|h\x7f\x1d{Gt\
4489 \xa2s:E\xe7tb{\xb3N\xef}IG\xcd\xcf\xcd\xe1p\xb1\xe8"\xa2_\x0b0\x9b\x83\xf1\
4490 \x17\x89%X\xc9\xf9\xfd\xe8s\xd9}rx\xf5rng.B\x00!\x85\x08\x05\x02\x97\tD\x00\
4491 \x1b\xa7\xcb\x8d\xbb\x07\xe5\xc1\xa3o\xdb[\xc3\xc3\x1f\x8b\x15\xc3\x9a\x84UT\
4492 \xa7\x90\xe2\xc2\xd9S\xf3\xc7\xe3\xf4q2=\xbfuN\xe2\xdfB\x96\xc1X}-"JIo\xde\
4493 \x8d\x93]yv\xfb\xe6E\x07\tWt\'\x95\x0bW88H\xe12\x02\x11\xcfw\x9f\xa6\xc9\xd7\
4494 \xa9\xe3\xcb\x19O\x9c9\x8ec\xe0\xee\x98\x01\x86;f\xd9\xec\x0f\xcc\x93\x94\
4495 \xa9E4O\xf8\x00\x00\x00\x00IEND\xaeB`\x82'
4496
4497 def getUYBitmap():
4498     return BitmapFromImage(getUYImage())
4499
4500 def getUYImage():
4501     stream = cStringIO.StringIO(getUYData())
4502     return ImageFromStream(stream)
4503
4504 index.append('UY')
4505 catalog['UY'] = ImageClass()
4506 catalog['UY'].getData = getUYData
4507 catalog['UY'].getImage = getUYImage
4508 catalog['UY'].getBitmap = getUYBitmap
4509
4510
4511 #----------------------------------------------------------------------
4512 def getUZData():
4513     return \
4514 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4515 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4516 \x00\x01dIDAT(\x91}\x91=K\\a\x14\x84\xe7\x85\xab`\xb1\x88\xb9\xa60`\x08"AHm\
4517 \xbd\x95\xa4\x92\x14\xe9\xd2\x19H\x13\xadR\xa4\xb0\x10k\x7f@@\x08\x04\x7f\
4518 \xc0B\xd8n\x8bt)\xe5\xa6\t\xe9V#+A\xb2~\xb0\x0bq\xd73g\xce\x9b\xe2f\x83E\xe2\
4519 S\x0c\xc3\xe10\xc5L\x026Z\xad\xb7++\xf3{{\x9f\x0f\x0e>\x02\xde\xe9\xec|\xfb\
4520 \xfas\xf9\xf1\xfc\xfa\xfa\x1b\xc0\x01\x03\x0c\x18\xd7&\x01\x1b\xc3\xe1\xbbN\
4521 \xa7[Ug\x11\xb1\xb9\xb9:\x1aiz:]\\\x8c\xf6\xf7\x0f\x9dAW\xad\xa4\xda\xed\xed\
4522 \x02@\xbf\x7f\xddl>:?\xbf^[[:=\x1d\x96\xf7fz\xbd_e9\xd3\xed^\xd2d\x94\x99\
4523 \x93Z\\\x9c\x05\xc6\xc5+|8y\xffd\xd0;\xbb/}\xf9\xe4\x92\x1f\x9b\xcbydzA\x8a\
4524 \x0c\xa3\x1bE\xce\xf2\xc1!\xfai0\xb8i4\xa6\x00\xe4\x9c\x91\x91\x91\xffGJ\xa9\
4525 \xaa\xbe\x17\x11Q\x7f\xe7\x9c\xff\x9a\x7f\x82\x94"\xbc\x08\xc4\xe4pg~\xce)gw\
4526 \xa4\xe7\xc0\xcb\xd7\xbbW\xc7\xbdp\x97Q\xa4\x9b\x8b\x14)\xa3\xd3e\x7f\x9a\
4527 \x9a[z\xb8U\xb5\x8b\xd63\x94O\x7f\x1c]\x9eP\xa4hn&\xa3h2:-H\x99\x8b.-\x97\
4528 \x19\x15\n\x8cA\xf9Bc\x81\xa2K\x1eu\xf8\xa4\xfdp\x97KR\x96B\x00\x12\x9a\x93)\
4529 o\x0fZk\xbdr\xc6m~\x03:<o^H\x87\xb8\xe7\x00\x00\x00\x00IEND\xaeB`\x82'
4530
4531 def getUZBitmap():
4532     return BitmapFromImage(getUZImage())
4533
4534 def getUZImage():
4535     stream = cStringIO.StringIO(getUZData())
4536     return ImageFromStream(stream)
4537
4538 index.append('UZ')
4539 catalog['UZ'] = ImageClass()
4540 catalog['UZ'].getData = getUZData
4541 catalog['UZ'].getImage = getUZImage
4542 catalog['UZ'].getBitmap = getUZBitmap
4543
4544
4545 #----------------------------------------------------------------------
4546 def getVAData():
4547     return \
4548 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4549 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4550 \x00\x01kIDAT(\x91U\x91\xb1NTa\x14\x84\xe7\xfc\xf7\xbf\xb0\xae\xba\xab\x1b\
4551 \xb6\x104&j\x0c\xa5\x05FH\xac,4\x16>\x8b\xcf\xe0\x13\xf8\x0e>\x81\xb1\xd3\
4552 \xc6\x02cb41\x16\x12\x9a\x85\x86bW"A\x02\xae\xec\x9d\x7f\xc6\xe2\xb2Q\xbezf\
4553 \xce9sb\xff\xeb\x10:\x002\x00\x81`\x91\xa0\x14\xdd;;HWt\x1eJ\x19:\xbaz\xfb%\
4554 \x00\xb8\xc0\x86\x0b@c!\xfaC\xa0\xe3\xf3\x8c\xc7\xe3\x8c\x16N\xe0b\x17\x98\
4555 \xf6\xcc\xd1I\x85\x0e\xd9\xb6\x8bm;"BR\x06\x04\x97\x7fj\x14\x9b\x06\x1di:\
4556 \xe5\xf1\xd1\xd6\xee\xee\xeb\xd3Y\xbdz\xf7Q\xaf\xb7,)I\x84=\xcf.\x16\xad\xc6\
4557 j\xec\xfcc\xffx\xf3\xd3\xab\xbaD\x1f;[\xdf\x9fO\x7f\x7f#\x99 \xc3t\xabvc76\
4558 \xed\xc6ez}\xe5\xf2\xb3\xa7/N\xf6\xf6F_\xfa\xf77\xdev\xfb\x8f%e\x01F\x99{\
4559 \xda\xf8\x99\xa3r,\x9e\x1c\xbe\xf95yw\xab\xf7p%\xae}\xfe\xf8a\xb0|c\xa1\xaa\
4560 \xb3\x08\xb8X\x8dA\x8bgC\x90\xad\xa6\xeen,\xdd\\?\x18m/V?\xd7\x1e<iT&\xe3I\
4561 \x96`\xf1l\r\xcf\x0f\x88l\xcd\xaaj\xe0\xe4\x8bk\xab\x91"\xe5\xdc\x89\x9ad&a\
4562 \x13\xd5\x10f\x98HD9Et"\x12"\x00\\\x18\x0cl\x00n\xfb\x8f\xd1{\xe8\x0f\x04\
4563 \x88\x10AB\x84\x80K\xf76\x85\xa5\xff\xdf\xdc\x1a\xfe\x02S\x96F.k8S\xc3\x00\
4564 \x00\x00\x00IEND\xaeB`\x82'
4565
4566 def getVABitmap():
4567     return BitmapFromImage(getVAImage())
4568
4569 def getVAImage():
4570     stream = cStringIO.StringIO(getVAData())
4571     return ImageFromStream(stream)
4572
4573 index.append('VA')
4574 catalog['VA'] = ImageClass()
4575 catalog['VA'].getData = getVAData
4576 catalog['VA'].getImage = getVAImage
4577 catalog['VA'].getBitmap = getVABitmap
4578
4579
4580 #----------------------------------------------------------------------
4581 def getVEData():
4582     return \
4583 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4584 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4585 \x00\x01fIDAT(\x91]\x91=kTa\x10\x85\xcf{sA\xb6H#iR,!\xc6N\xff\x80Z\x9a@\x922\
4586 \xd8\xdb+"\nIa\x93\x7f\x10\xb4I#l\xf2\x03b\x93\xc0\x16\xf1"laca)\x88_\x10S\
4587 \xa8!"n\xb6\xd89gf,\xee&\xa8\xf0\xf00_\x9cf\x8a\x9f\xe0\xf0\x1bPa\xf92"\x00\
4588 \x00\x01\x04\xe2\x02 \x84\x08\x84\x10B\xbd\xb8\x87\xfd\xe1f\xe7\xb1\xbfx7\
4589 \xbdv\xfd\'\xe0\x99\x0e\xa8\xa4\xa6\xa0*\x99\xa9<\xf7\xd9\x9b\xfd\xba\n<\xb5\
4590 \xbb\xc7\x0fl\xed\xd13\xe0W&\x01\xcf\xe4_X\xa6e\xb2\x94n\x08u\xb3\x8c\x9c\
4591 \x7f\x0e|m\xef\x00\xcf\xb4\xf3\xd4\xc9ik\x80!\x14`\xb0\xb1\xb1pt4\x96 \x06\
4592 \x95\xbd^\xb7\xd3\xa92s4\xd2\xea\xea\'2\xcc\x82\xcc\xb9\xb9K\x83\xc1\xab\n\
4593 \x08)\xc8$\x83\xcc^\xaf\xdb4\xc3\x95\x95\x8fKK\x1f\xfa\xfd\xdf\x07\x07\xf3f\
4594 \xd1"\x05\xa0\x1a\x90;\xa44\xe6\xeeN\xb7i\x86\xdb\xdb?\xcc\xd2,\xb6\xb6\xbe\
4595 \x8f\xc7~\xf8r\xe1\xe6\x8d\xf7m"\xa0r\x1b\xb7\xee\xdf{x\xfa\xe5\xd4\xe5nr\
4596 \xbaZSn!\xcaMA\x97|\xe6\xca\xcc\xfa\xdb\'u\x1f\xaf\xa7t-\xf8\x19d\x92i\x96f\
4597 \x93\xe2b"B^\xfc\xea\x1d\xa0\x0e\xa0\xa20;\x9b$\xe4\x10A\x16\x12\x12ZKpo\t\
4598 \xa0\x8c&\x9f\x9d\x80\x7f\xdb\xffV\x00\xfe\x00\x7f\xf4Zt\x97\xd3\xc4\xb3\x00\
4599 \x00\x00\x00IEND\xaeB`\x82'
4600
4601 def getVEBitmap():
4602     return BitmapFromImage(getVEImage())
4603
4604 def getVEImage():
4605     stream = cStringIO.StringIO(getVEData())
4606     return ImageFromStream(stream)
4607
4608 index.append('VE')
4609 catalog['VE'] = ImageClass()
4610 catalog['VE'].getData = getVEData
4611 catalog['VE'].getImage = getVEImage
4612 catalog['VE'].getBitmap = getVEBitmap
4613
4614
4615 #----------------------------------------------------------------------
4616 def getVNData():
4617     return \
4618 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4619 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4620 \x00\x01\x0bIDAT(\x91}\x91!N\xdda\x10\xc4\xe7O\x9f\x00A\x13$\xe2id\x1d\x86\
4621 \x03 8E]\xaf\xd0 @\xc0U\xdaj\x0eQ\xd5S4\x80"\x88\x866ag\xf6\xfb!>Rx\ta3\xd9\
4622 \xac\xd8\x99\x9d\xec,\xe8\xa5\xc6\xe6\xfc&\x16$\x9d\x9eJb\x0c\x8d\xa1n\xd2\
4623 \xea\x90(\xc1\xe6U\x7f\xb8\xbaZI\x92\xe0\xfaF\xdd\xea\xc6V7\x07f\x98_\xa6\
4624 \x8c\x8b*\xece\xbd\x1e\xd2J\x12\x83\x8d\xed*\x8e\xc3\xae\xf9Y\xb8(O\x82\xec!\
4625 \xad\x86\xb4t+!Q\x87\x0b\xf3\xcf|2\x98\xcbb\xaf\xf8\xfcB\xd0\xbc\xa0\xf4t)\
4626 \x873\xf3\xad\xc0`\x0e\x8b\x13\xf3\xe7\xd9\x92\x92!mI\xa2C\x82\x0b\x17w\xc5\
4627 \xd7\x82\x82G\xce\x8b\xdf\x8fTM\xbc\xb2dS\xa5d*qY|1\xf7\xe6{\xf1\xc3\xff\xe5\
4628 I2\t\x1f\x92i\x11\x9bUqR\xdc\x9a*\x8e\xcc\xb6y(b\xa5\xd5\xadI\xd8r\xb4\xbf\
4629 \x8f\xad\xb4b\xd9\xcb\xdaJdk\'\xfa\x98\xf9Cu\x0fi\xf9\xbb\x19\xe4;\x19\xcfz\
4630 \x02\x8bsUM\x8a:d\x82\x00\x00\x00\x00IEND\xaeB`\x82'
4631
4632 def getVNBitmap():
4633     return BitmapFromImage(getVNImage())
4634
4635 def getVNImage():
4636     stream = cStringIO.StringIO(getVNData())
4637     return ImageFromStream(stream)
4638
4639 index.append('VN')
4640 catalog['VN'] = ImageClass()
4641 catalog['VN'].getData = getVNData
4642 catalog['VN'].getImage = getVNImage
4643 catalog['VN'].getBitmap = getVNBitmap
4644
4645
4646 #----------------------------------------------------------------------
4647 def getVOLAPUKData():
4648     return \
4649 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4650 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4651 \x00\x01\x85IDAT(\x91eP\xc1\x8a\x82P\x00|>\xd4T\xd2H\x14\xb3B\x92N\x85\x94\
4652 \x97\x0e}B\xa7>:\xe8Z\x97\nR)K\xd4(\x93\xd2\xc8\x97\xca\xdbC\x87v\xb7\xb9\r3\
4653 \xc3\x0cC`\x8c\xc1\x17\xe28N\x92D\xd3\xb4o\x89\xfc\xc7\x1d\xc7Q\x14\xc5\xb2\
4654 \xac0\x0c\x05A@\x08)\x8a\xf2\xdb@\xbc\x1bf\xb3\x99m\xdb\x96e\xd5j\xb5\xe1p\
4655 \xa8i\xdav\xbb-\xcb\xd2q\x9c<\xcf;\x9d\x8e(\x8a\x93\xc9\xe4\x13\x00\x00\x84a\
4656 \xb8X,0\xc6\xbb\xdd\x8ee\xd9,\xcb\xa2(\x1a\x8f\xc7\xf5z]\xd7uQ\x14?\rQ\x14-\
4657 \x97\xcb\xeb\xf5\xfax<\xe286Ms\xb3\xd9\x94e\xa9(\n\xcf\xf34MGQt\xbf\xdf\xa7\
4658 \xd3\xa9,\xcb0I\x92\xfd~/\xcbr\xab\xd5\xc2\x18\xb3,K\x92\xa4$I\x10B\xdf\xf7=\
4659 \xcf;\x1c\x0e\x10B\x8e\xe3\\\xd7M\xd3\x14\x06A\x90\xa6i\x18\x86\xf3\xf9\x9c \
4660 \x08\x86a^\xaf\xd7\xe5r\xe9\xf7\xfb<\xcf\xeb\xba\x0e\x008\x1e\x8f\x82 \xdcn7\
4661 \xdf\xf7\xc9j\xb5\n\x00h6\x9b4MS\x14\x95\xe7\xb9m\xdb\x86adY\xf6\xde=\x18\
4662 \x0c\xca\xb2t]\x17!d\x9a&\x811v\x1cg\xbd^3\x0c\xc3q\\\x9a\xa6\x92$\x05A\x10\
4663 \x04\xc1h4\xca\xb2\x8c \x88\xa2(\x10B\xbd^OUU\x12\x00\xd0\xedveY\xf6<\x0f\
4664 \x00\xd0n\xb7UU]\xadV\x10B\xc30N\xa7\xd3\xf3\xf9\xa4(\xaa\xd1hT*\x95?\xb7\
4665 \xfe\xc6\xf9|.\x8aBU\xd5o\xe9\x07I\xbb\xd4\xc3\x9c&\xc1D\x00\x00\x00\x00IEND\
4666 \xaeB`\x82'
4667
4668 def getVOLAPUKBitmap():
4669     return BitmapFromImage(getVOLAPUKImage())
4670
4671 def getVOLAPUKImage():
4672     stream = cStringIO.StringIO(getVOLAPUKData())
4673     return ImageFromStream(stream)
4674
4675 index.append('VOLAPUK')
4676 catalog['VOLAPUK'] = ImageClass()
4677 catalog['VOLAPUK'].getData = getVOLAPUKData
4678 catalog['VOLAPUK'].getImage = getVOLAPUKImage
4679 catalog['VOLAPUK'].getBitmap = getVOLAPUKBitmap
4680
4681
4682 #----------------------------------------------------------------------
4683 def getVUData():
4684     return \
4685 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4686 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4687 \x00\x01\x91IDAT(\x91M\x8bM\x88\xcc\x01\x18\xc6\x9f\xff\xcc\xdf\xc7\xbap\x13\
4688 Z\xdar2\xd8\xc3\xb8Hj\x0f\x9c\xe40,\xe5\xe30\x07N\x8a\xd3\xba\xac3\xce\xa3\
4689 \xbd\xae"E\x8a\x1a\xe5\xc6A\xb1J{\xd9\x89\x93\x96B.v\xd7\xc7,\xffy\x9f\xe7}_\
4690 \x07\xb3\xa5~\xfdz\x0e\xbf\x07\xfbv\xe0\xedC\x8c\x003\x80\xff\x07\x81\x01\
4691 \xf0\x07X\x05~\x01?\x80\x15`\t({_\xb0\xd0\x9f\xfe\xfc\xbe|0k=\x8f\xfd\xee)\
4692 \x87\xab\x90\xeaR\x8dL)\xd7\xdc\xefvK\x00\xef\x16s\xe9\xdb\xc7Sgj\xb7nT?\xc9\
4693 C\xf2$\x87\x18\x93\x96fI\x16\xa3\xa3\x01\xd4\x00\x84\xe7\x9b\x05\xbf\xd7\xad\
4694 .]-\x9e\xb8?\xa5\rS\xb3\xe4 \xcd\x86\x90\x01\x94\x00\xce\x1e\xf7\xad\x9b\xb5\
4695 \xfc]w\x1e\xeb\xca4.^cG4\xa7\xdcLfN\xba\x99s\x97\xf3\xd9\xbfCU\xf9\xcd\xfb\
4696 \x9c\xba\xa0\x97\xf3\xaa*\xde\xbe.g\x11\x81\x8c"\xa2\x16Qd\xd4\xc3}\xdd\xa6z\
4697 \xef\x11J\x00\x9f\xbe\xea\xd8\x84\x96W\xac\xd9P\xbbU\x9c\xbe\\\x99Q4#iC\x93\
4698 \x1c\x1b\xeb\xbfz\x8d\x12\xc0\xf39~X\xb4\x03{\xd5n\xe1|\xa7?\x98\xb4\xc1\x11\
4699 \xd2iaL\x9a\x1b\x93J\r6\x08/P\x02\x10\xd5l\xb0\xdd*\xceuVm\xc2\xaa\x83\xc6\
4700 \x8a\x16\xc6\xa0\x05\x99\xa6\xa0\xc2U8\xfa(\x01\xec\xd9\xad\x13GwN\xdd\xfd\
4701 \xbd\xed\xe4\x166H\'\xd7S)\x06\x95R\xc8\xd3=\xdc\xd3a(\x0b\xa092\xbb}\x1c8\
4702 \x0c\x8c\x03s@\x00\x02\x0c\x88\xb5-\x00\x80\x80\x8d\xf8\x0b$\xc5Q\x9b\'}\x7f\
4703 \xc4\x00\x00\x00\x00IEND\xaeB`\x82'
4704
4705 def getVUBitmap():
4706     return BitmapFromImage(getVUImage())
4707
4708 def getVUImage():
4709     stream = cStringIO.StringIO(getVUData())
4710     return ImageFromStream(stream)
4711
4712 index.append('VU')
4713 catalog['VU'] = ImageClass()
4714 catalog['VU'].getData = getVUData
4715 catalog['VU'].getImage = getVUImage
4716 catalog['VU'].getBitmap = getVUBitmap
4717
4718
4719 #----------------------------------------------------------------------
4720 def getWSData():
4721     return \
4722 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4723 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4724 \x00\x01)IDAT(\x91e\x91\xc1JBQ\x14E\xf7\xd3\x97\x83FBM\x1cX\xd4\xb0\xa18\x08\
4725 \xfa\x01?\xa0Y\xbf\xd1\xcc\x1f\xa9\xdfpX\x81\x10a\x10H4\x90HS\xa2 B\x1a$\x14\
4726 <\xcf\xde\xf7\x9e\x06OS\xf3\xb0\xd9\x93\xbb\x16\xe7\xc2I\x80#,&\x026\xefl\
4727 \x8aa\x04\xfe%\x05\xd0l\x9e\xee\xedo\xd7\xeb\xbbW\x97\x8f\xb5Z\xb5\xdb}\x1b\
4728 \xbf\x8e\x83bQ7\x05\xd2%\x9f\xf7w\xab\x95\x02\x00|wg\xeb\xfc\xec\xda,\x94\
4729 \xcb\x9b\x9d\xces\x89S2D\x0e\xdd\xe847s2\xa9V#P\x00b\x8ch\xb7\x9f&\x93\xac\
4730 \xd18\xe8\xf5\xde\xcd\xdc(\xb3\xe0f\xce\xa9\x9b\xcdB\xce\x84\x10\n\xa3\xd1\
4731 \xe7\xf1\xc9\xe1W\xe6\xfd\xfe\x98\x04M4\xba\x99OmY\x00\x90\x02\x96*+1\xbb\
4732 \xbbx\x18\x0e>6\x14`2\x8a\xcc7pAK\x11H\x03\xee\x11n]/>0P\xce\xfc\xd3\\\xd0\
4733 \xf3N\xc8\x08\xa4\x11HH7\x83\xb4\x02\xad\xd2\x90\\R.\x14%\'\xf1\x07\xadk"\
4734 \x14\x10\x02r\xa1@\xa1Rq\x12\n\x10A&$$\xe4-!\x84<\x11H~V\x0f\x89\xb5\xd3.?\
4735 \x01\xf8\x05o\xd3]\x10"\x992\xd8\x00\x00\x00\x00IEND\xaeB`\x82'
4736
4737 def getWSBitmap():
4738     return BitmapFromImage(getWSImage())
4739
4740 def getWSImage():
4741     stream = cStringIO.StringIO(getWSData())
4742     return ImageFromStream(stream)
4743
4744 index.append('WS')
4745 catalog['WS'] = ImageClass()
4746 catalog['WS'].getData = getWSData
4747 catalog['WS'].getImage = getWSImage
4748 catalog['WS'].getBitmap = getWSBitmap
4749
4750
4751 #----------------------------------------------------------------------
4752 def getYEData():
4753     return \
4754 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4755 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4756 \x00\x00\xf8IDAT(\x91\x95\x8f=JCQ\x10\x85\xcf\x95\xdb<H@\xac\x02b\x93\x8d\
4757 \xa4\tYN6`m\x99G\x16\xe1\n\\Ev\x11\x08\x88v\x16I,\xee\x999\xc7\xe2\x91g\n\
4758 \x15\xfc\x18f\xce\xfc\xc2\x94\x0f|\xa3\x8b\xbf\x16\xa3\x05 \xa0\x02\xe8\x9e\
4759 \x1e\x01\xd8B\nJG"\xc3\x19\x8ep\xd0\x11\x08\x8a\xe1\xe0\xfb\xf3K\x05\x00Xo\
4760 \xaf\xc8t\xa6\x83`:\xe8\xa0I\x07\xdd\x9a\xd8L\xde\xdc?\x08\xa8\xb7\x9b\x8d\
4761 \x17\x0b\x9cN\xb0-A\xb2\xe4L\xa7l9\xd3JGZ*\x93\xc9\xddg-\xe7\xf3\xb9\xeb:\
4762 \x00\xb6a\x18\xfe\x8dR\xca\xe1p\xa8\x92\x86i\xdb\xa3\xf8\x11\x94"\xa9J\xba\
4763 \x14\xfe\xbco\x17[R\xddn\xfb\xe5ru<\x1e3S\xd2\xe8Gl\x0f\xc5\xe9t\xda\xf7}\
4764 \x01\xb0^\xaf\xf7\xfb=I\x92\xad\xb5\xab\xc0F\x06\x19\x11\x111\x9f\xcfw\xbb]\
4765 \x05@\xc6l6\xe3\xd0`0\x18\x11\x97\x94)\r\x0b\xc3\xb7\xff\xe6\x0bV3a\xa2\xea\
4766 \xf3oS\x00\x00\x00\x00IEND\xaeB`\x82'
4767
4768 def getYEBitmap():
4769     return BitmapFromImage(getYEImage())
4770
4771 def getYEImage():
4772     stream = cStringIO.StringIO(getYEData())
4773     return ImageFromStream(stream)
4774
4775 index.append('YE')
4776 catalog['YE'] = ImageClass()
4777 catalog['YE'].getData = getYEData
4778 catalog['YE'].getImage = getYEImage
4779 catalog['YE'].getBitmap = getYEBitmap
4780
4781
4782 #----------------------------------------------------------------------
4783 def getYUData():
4784     return \
4785 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x11\x00\x00\x00\x0b\x08\x06\
4786 \x00\x00\x00\x99 f\x07\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\x00\
4787 \x01'IDAT(\x91\x9d\x91\xbdJ\xc3`\x14\x86\xdf$_C\x9a\x984E\xab\xc1A\rEQ\xc9\
4788 \xe2\xe0\xe05\x88\xa3\x93\x8b\x827\xe1e\x88\x83\x9b\xae^\x85\x93\xf0!B\xa7\
4789 \x06\x1c,U,\xda\x14\x0bI%6i\x93|.\x1a4\xa5M\xf5\x19\xdf\xc3y8?\xdc\xc9\xea:3\
4790 e\x05\xff\xa5\xf9\xe1\x83\x98\xb2\x02K+\xfd*\x84$\xc1\x90D\x98\t\xc4\xa9D$\
4791 \x1b<\xe8@\xb8\xd2\x03_\xe4 4$\xacu\x92|\xc9U\xa4\xd6g\x87\xfa\xfbw\xb0\xbbT\
4792 5\xe7\xcb\xdd28\xc05\xf4\xdey\xa7\xd5\x0c\x86Q<N\xd0\x8d\x12\x95\\\x1b;\x16\
4793 \xe6\xaaix`\xba\xf0^=0\xf0\xd0\xcc\x85\xca]\x7f\xa3r\xefs\xe3\xc7xk\x80\xcff\
4794 \xbe\xae\x83\x0bE(q\x11\x03c1w\x15\x00\xa3\x12\xdei\xa3\x00@\x94$\xc4/-\x04\
4795 \xc9\x84)\xbe \xfb\x9bb\xddX\x96\xd2\x9b\xf0\xcf\xb5m_\x90I\x9f\tP\x1ei\xb2g\
4796 \x1d\xdfN\x12\xb4\x9fD\x15\x94R\xf6\x93\x81\xeb\xb1\xda\xc5%\xbb9=c\x81\xe3\
4797 \xb0<(\xa5l\xe4\xc5\x85\x92\x86\xad\xa3\xc3\xa9n\x91\xaec\xdb\xf6\x9f\x1a\
4798 \xb2\xd8\xb6\x8dO>1\x8eT\x1c4\xb0\xeb\x00\x00\x00\x00IEND\xaeB`\x82"
4799
4800 def getYUBitmap():
4801     return BitmapFromImage(getYUImage())
4802
4803 def getYUImage():
4804     stream = cStringIO.StringIO(getYUData())
4805     return ImageFromStream(stream)
4806
4807 index.append('YU')
4808 catalog['YU'] = ImageClass()
4809 catalog['YU'].getData = getYUData
4810 catalog['YU'].getImage = getYUImage
4811 catalog['YU'].getBitmap = getYUBitmap
4812
4813
4814 #----------------------------------------------------------------------
4815 def getZAData():
4816     return \
4817 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4818 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4819 \x00\x01\xd3IDAT(\x91M\xc6OH\x93q\x1c\xc7\xf1\xcf\xb3\xfd\xb6\xb6\xe7\x19\
4820 \x1a\x9a\rJ\x91`5\x0fu(B\x84\x92\xa4\xa0\xa0 \xa1\xa0\xaeu\x89":\t\xf3RF\x88\
4821 P\xb7\xacnA\x1d;HPF\x10EDT\x82)\xc1\xeaP\x1e\xb2y\xc8\x9e\x9c9d{\xf6\xe7\xf7\
4822 \xfd\xf3\xeb A\xf0\xe2\xcd\x1b\x98\xe8\xc4D\xfb\x897\xa3\x0b\xc5\xb9j>/\xc0\
4823 \x06\x02Z@\x03\x88\x80*\xb0\x0eT\x80?\x80w\xe3\x1dl\xe2\x1e\x94\xb3\x1d\xdbO\
4824 m\x1d\xecz\xfd\xde|\x98\x81\x90c\x06\xb3#r\xff\xb56=m\xf6}C\xff\xd9\xea\xb5\
4825 \xf9\xda\xd2\xd2\xef\x8f\xe1\x97\xd1\xa1\xf3;\xeb533\xe7J\x8b\x8e\xc8Yrd\x9d\
4826 \xb5\x8e\xc8\xeb\xe9Q\xc0\x030\xfbvlG~e\xfc\xab\xff\xabiD\x1a#{/\xe6\x92\xed\
4827 \x1d\x8b\xcb.\x8a\x9c\xaaSq\xa2N\xd5K\xfb\xebSS\x1e\x80B\xa1\xb0\xbb/\x1c\
4828 \x1a\xc4d)\xfd\x93\x13k\xb6%\x0e\xa9xJ\x94I6\x109\xee\xced\x9f\xdc\x994\x00\
4829 \x98\xe5\xe9\xf3\xa8\\\x89\x17N6n\xfdH\x95\xd5or\xbdZ\r\xad\x90\x15KBV\x89\
4830 \x847I\x0b!\x0c\x00\x11>z8v\xe4\x90\xde/%K\xadD\x93#v\xea\x07\x9dIQ\x12"aV"\
4831 \xe5\x8c\xbf\x05\x19\x18\x00\xc3\xc7\xbc\xbe=\xde\xcd\x85\xe0s\xd5X\x1b\xdd=\
4832 x=\x88\x05\xab\xdf\x83zMD\x9c\xaaSu\xa2\x9a\tL\xf7\xae\x0b\xe6\xe18\xf2\xfd\
4833 \xe6\xcal\xdbj\xc4H\xd0\xc8\xfes\xaf\x1e%\x9e=\xae\x84\xe5e"\xb5\xe4\xc8*\
4834 \xb32k.\x97.\x16_\x1a=\x8e\xab\xc5\xc0\x8f\xc5\x07z\xbb\xcel\x1b~\xf1 =\xff\
4835 \xa9\x16\xb4\xa1\xd7O\x13)\xb3cV\x11\'\xa2"\x00\xd4\xc3%\x80\x91\x1d80\xb6\
4836 \xf9\xf6\xe5\xd3+@\x08(\xa0\x80\xfd7\x0c0\x00\x80\x81\xe4_\xe0B._\xd7\x89\
4837 \x0c\xe6\x00\x00\x00\x00IEND\xaeB`\x82'
4838
4839 def getZABitmap():
4840     return BitmapFromImage(getZAImage())
4841
4842 def getZAImage():
4843     stream = cStringIO.StringIO(getZAData())
4844     return ImageFromStream(stream)
4845
4846 index.append('ZA')
4847 catalog['ZA'] = ImageClass()
4848 catalog['ZA'].getData = getZAData
4849 catalog['ZA'].getImage = getZAImage
4850 catalog['ZA'].getBitmap = getZABitmap
4851
4852
4853 #----------------------------------------------------------------------
4854 def getZWData():
4855     return \
4856 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x0b\x08\x02\
4857 \x00\x00\x00\xf9\x80\x9an\x00\x00\x00\x03sBIT\x08\x08\x08\xdb\xe1O\xe0\x00\
4858 \x00\x01\x9aIDAT(\x91M\x91?h\x93q\x14E\xdf/\xfd\x9a\xf8\'\xd1I*\xd2R\x03u\
4859 \xa8\x82.N\x0e\x0eJ\x91\x12h\xc0\xa1B\x04\x11A\\\xd5\xb1\x82\x83\x93\xab:U7\
4860 \x87\x82"\x88]2hE\x85\xa0NE\x97L\x1d:\xb9X#1_\x93\xbc\xfb\xde\xbb\x0e5\x12\
4861 \xb8p\xcf|Njo\xb7\xe7\x97\xe7eI\xc4DB$Dl\xc4*b":\x06EI\xf9\x9f\xbc\xb4\xbf\
4862 \xb4\xda|0s\x1a\xce\x08z\xd0\x83\x164\x0f\xf3\x80\xd3<\xe0aF\xdc\xf9\xb8\x9e\
4863 \xf2<?0Y\xf2\x027\xde\xdeZX\xe83A\xc4I\x8cMI%\x91\xd2L\xb7\xdb\xccD\x84\x13\
4864 \x0f\xf3\x17\xe5\x8b\xcb\xabk\xf7n\\\x88A!)\xcd\x02\xa0)M\xc3@h\x18\xb2)\xb4\
4865 \x1fI\xd6}\xbcR\xa8\x1f\xaf\\\xf9\xf2\xfb\xe9\xaf\xc5\xe9\xe9\xd7_\xb7N\xf4s\
4866 \x07\x02 \xd4\xa1\xae\x08\xa8\x03\x07{X\x13I;\xad\x8dlk\xb3\xdc\xf8L\xda\xee\
4867 \xfb\xc6\xe4\xf9\xa5\xc5Z\r\xc3!\x00U\xd5\x7f\xa7\x00\xaa\xd5j\xab\xd5\xca\
4868 \xb2\x93g\xfd\xfb\x07\xd2v?\x1d.\x9c\xab\xbd\xbc^\x7frd\xe0@@\x03\x08(\r\x01\
4869 \r\xc3\xbe)\xbc\x13\xc9B\xe2\xd0\xcd\xfb\x11\xc13\x9d\xe7\xb7\x1b\x97&zYR\
4870 \x06B\xc0\xa4\x91\x10I\x99\xc0\x82\x15\x8b6\'\x92:\x9dN\xa5R\x19\x0ez\xebo\
4871 \xae^\xaew\x98)\xa9\x8c=9#K\x02\xa1\xa74\xb7\xf3\xf3[\xea\xf7\xfb\x03\x0c\
4872 \x9f5\xef\x1e=5RN\x8b\x80\x13\x16\x16\xfe\xbf\x89\x93\xbe\xf2j3m\xff\xd8\x9e\
4873 =6+\xd7Dz\xa3\xa8:\x8a=\xce{\xed\xcb\xf2\x17\xc6\xbc\\0\x92\xc2\xa7\xad\x00\
4874 \x00\x00\x00IEND\xaeB`\x82'
4875
4876 def getZWBitmap():
4877     return BitmapFromImage(getZWImage())
4878
4879 def getZWImage():
4880     stream = cStringIO.StringIO(getZWData())
4881     return ImageFromStream(stream)
4882
4883 index.append('ZW')
4884 catalog['ZW'] = ImageClass()
4885 catalog['ZW'].getData = getZWData
4886 catalog['ZW'].getImage = getZWImage
4887 catalog['ZW'].getBitmap = getZWBitmap
4888
4889